diff options
Diffstat (limited to 'wp-includes/js/dist/nux.js')
| -rw-r--r-- | wp-includes/js/dist/nux.js | 744 |
1 files changed, 744 insertions, 0 deletions
diff --git a/wp-includes/js/dist/nux.js b/wp-includes/js/dist/nux.js new file mode 100644 index 0000000..f752585 --- /dev/null +++ b/wp-includes/js/dist/nux.js @@ -0,0 +1,744 @@ +/******/ (function() { // webpackBootstrap +/******/ "use strict"; +/******/ // The require scope +/******/ var __webpack_require__ = {}; +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/compat get default export */ +/******/ !function() { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function() { return module['default']; } : +/******/ function() { return module; }; +/******/ __webpack_require__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ !function() { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = function(exports, definition) { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ !function() { +/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } +/******/ }(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ !function() { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ }(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + DotTip: function() { return /* reexport */ dot_tip; }, + store: function() { return /* reexport */ store; } +}); + +// NAMESPACE OBJECT: ./node_modules/@wordpress/nux/build-module/store/actions.js +var actions_namespaceObject = {}; +__webpack_require__.r(actions_namespaceObject); +__webpack_require__.d(actions_namespaceObject, { + disableTips: function() { return disableTips; }, + dismissTip: function() { return dismissTip; }, + enableTips: function() { return enableTips; }, + triggerGuide: function() { return triggerGuide; } +}); + +// NAMESPACE OBJECT: ./node_modules/@wordpress/nux/build-module/store/selectors.js +var selectors_namespaceObject = {}; +__webpack_require__.r(selectors_namespaceObject); +__webpack_require__.d(selectors_namespaceObject, { + areTipsEnabled: function() { return selectors_areTipsEnabled; }, + getAssociatedGuide: function() { return getAssociatedGuide; }, + isTipVisible: function() { return isTipVisible; } +}); + +;// CONCATENATED MODULE: external ["wp","deprecated"] +var external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; +var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject); +;// CONCATENATED MODULE: external ["wp","data"] +var external_wp_data_namespaceObject = window["wp"]["data"]; +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/reducer.js +/** + * WordPress dependencies + */ + + +/** + * Reducer that tracks which tips are in a guide. Each guide is represented by + * an array which contains the tip identifiers contained within that guide. + * + * @param {Array} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Array} Updated state. + */ +function guides(state = [], action) { + switch (action.type) { + case 'TRIGGER_GUIDE': + return [...state, action.tipIds]; + } + return state; +} + +/** + * Reducer that tracks whether or not tips are globally enabled. + * + * @param {boolean} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ +function areTipsEnabled(state = true, action) { + switch (action.type) { + case 'DISABLE_TIPS': + return false; + case 'ENABLE_TIPS': + return true; + } + return state; +} + +/** + * Reducer that tracks which tips have been dismissed. If the state object + * contains a tip identifier, then that tip is dismissed. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ +function dismissedTips(state = {}, action) { + switch (action.type) { + case 'DISMISS_TIP': + return { + ...state, + [action.id]: true + }; + case 'ENABLE_TIPS': + return {}; + } + return state; +} +const preferences = (0,external_wp_data_namespaceObject.combineReducers)({ + areTipsEnabled, + dismissedTips +}); +/* harmony default export */ var reducer = ((0,external_wp_data_namespaceObject.combineReducers)({ + guides, + preferences +})); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/actions.js +/** + * Returns an action object that, when dispatched, presents a guide that takes + * the user through a series of tips step by step. + * + * @param {string[]} tipIds Which tips to show in the guide. + * + * @return {Object} Action object. + */ +function triggerGuide(tipIds) { + return { + type: 'TRIGGER_GUIDE', + tipIds + }; +} + +/** + * Returns an action object that, when dispatched, dismisses the given tip. A + * dismissed tip will not show again. + * + * @param {string} id The tip to dismiss. + * + * @return {Object} Action object. + */ +function dismissTip(id) { + return { + type: 'DISMISS_TIP', + id + }; +} + +/** + * Returns an action object that, when dispatched, prevents all tips from + * showing again. + * + * @return {Object} Action object. + */ +function disableTips() { + return { + type: 'DISABLE_TIPS' + }; +} + +/** + * Returns an action object that, when dispatched, makes all tips show again. + * + * @return {Object} Action object. + */ +function enableTips() { + return { + type: 'ENABLE_TIPS' + }; +} + +;// CONCATENATED MODULE: ./node_modules/rememo/rememo.js + + +/** @typedef {(...args: any[]) => *[]} GetDependants */ + +/** @typedef {() => void} Clear */ + +/** + * @typedef {{ + * getDependants: GetDependants, + * clear: Clear + * }} EnhancedSelector + */ + +/** + * Internal cache entry. + * + * @typedef CacheNode + * + * @property {?CacheNode|undefined} [prev] Previous node. + * @property {?CacheNode|undefined} [next] Next node. + * @property {*[]} args Function arguments for cache entry. + * @property {*} val Function result. + */ + +/** + * @typedef Cache + * + * @property {Clear} clear Function to clear cache. + * @property {boolean} [isUniqueByDependants] Whether dependants are valid in + * considering cache uniqueness. A cache is unique if dependents are all arrays + * or objects. + * @property {CacheNode?} [head] Cache head. + * @property {*[]} [lastDependants] Dependants from previous invocation. + */ + +/** + * Arbitrary value used as key for referencing cache object in WeakMap tree. + * + * @type {{}} + */ +var LEAF_KEY = {}; + +/** + * Returns the first argument as the sole entry in an array. + * + * @template T + * + * @param {T} value Value to return. + * + * @return {[T]} Value returned as entry in array. + */ +function arrayOf(value) { + return [value]; +} + +/** + * Returns true if the value passed is object-like, or false otherwise. A value + * is object-like if it can support property assignment, e.g. object or array. + * + * @param {*} value Value to test. + * + * @return {boolean} Whether value is object-like. + */ +function isObjectLike(value) { + return !!value && 'object' === typeof value; +} + +/** + * Creates and returns a new cache object. + * + * @return {Cache} Cache object. + */ +function createCache() { + /** @type {Cache} */ + var cache = { + clear: function () { + cache.head = null; + }, + }; + + return cache; +} + +/** + * Returns true if entries within the two arrays are strictly equal by + * reference from a starting index. + * + * @param {*[]} a First array. + * @param {*[]} b Second array. + * @param {number} fromIndex Index from which to start comparison. + * + * @return {boolean} Whether arrays are shallowly equal. + */ +function isShallowEqual(a, b, fromIndex) { + var i; + + if (a.length !== b.length) { + return false; + } + + for (i = fromIndex; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + + return true; +} + +/** + * Returns a memoized selector function. The getDependants function argument is + * called before the memoized selector and is expected to return an immutable + * reference or array of references on which the selector depends for computing + * its own return value. The memoize cache is preserved only as long as those + * dependant references remain the same. If getDependants returns a different + * reference(s), the cache is cleared and the selector value regenerated. + * + * @template {(...args: *[]) => *} S + * + * @param {S} selector Selector function. + * @param {GetDependants=} getDependants Dependant getter returning an array of + * references used in cache bust consideration. + */ +/* harmony default export */ function rememo(selector, getDependants) { + /** @type {WeakMap<*,*>} */ + var rootCache; + + /** @type {GetDependants} */ + var normalizedGetDependants = getDependants ? getDependants : arrayOf; + + /** + * Returns the cache for a given dependants array. When possible, a WeakMap + * will be used to create a unique cache for each set of dependants. This + * is feasible due to the nature of WeakMap in allowing garbage collection + * to occur on entries where the key object is no longer referenced. Since + * WeakMap requires the key to be an object, this is only possible when the + * dependant is object-like. The root cache is created as a hierarchy where + * each top-level key is the first entry in a dependants set, the value a + * WeakMap where each key is the next dependant, and so on. This continues + * so long as the dependants are object-like. If no dependants are object- + * like, then the cache is shared across all invocations. + * + * @see isObjectLike + * + * @param {*[]} dependants Selector dependants. + * + * @return {Cache} Cache object. + */ + function getCache(dependants) { + var caches = rootCache, + isUniqueByDependants = true, + i, + dependant, + map, + cache; + + for (i = 0; i < dependants.length; i++) { + dependant = dependants[i]; + + // Can only compose WeakMap from object-like key. + if (!isObjectLike(dependant)) { + isUniqueByDependants = false; + break; + } + + // Does current segment of cache already have a WeakMap? + if (caches.has(dependant)) { + // Traverse into nested WeakMap. + caches = caches.get(dependant); + } else { + // Create, set, and traverse into a new one. + map = new WeakMap(); + caches.set(dependant, map); + caches = map; + } + } + + // We use an arbitrary (but consistent) object as key for the last item + // in the WeakMap to serve as our running cache. + if (!caches.has(LEAF_KEY)) { + cache = createCache(); + cache.isUniqueByDependants = isUniqueByDependants; + caches.set(LEAF_KEY, cache); + } + + return caches.get(LEAF_KEY); + } + + /** + * Resets root memoization cache. + */ + function clear() { + rootCache = new WeakMap(); + } + + /* eslint-disable jsdoc/check-param-names */ + /** + * The augmented selector call, considering first whether dependants have + * changed before passing it to underlying memoize function. + * + * @param {*} source Source object for derivation. + * @param {...*} extraArgs Additional arguments to pass to selector. + * + * @return {*} Selector result. + */ + /* eslint-enable jsdoc/check-param-names */ + function callSelector(/* source, ...extraArgs */) { + var len = arguments.length, + cache, + node, + i, + args, + dependants; + + // Create copy of arguments (avoid leaking deoptimization). + args = new Array(len); + for (i = 0; i < len; i++) { + args[i] = arguments[i]; + } + + dependants = normalizedGetDependants.apply(null, args); + cache = getCache(dependants); + + // If not guaranteed uniqueness by dependants (primitive type), shallow + // compare against last dependants and, if references have changed, + // destroy cache to recalculate result. + if (!cache.isUniqueByDependants) { + if ( + cache.lastDependants && + !isShallowEqual(dependants, cache.lastDependants, 0) + ) { + cache.clear(); + } + + cache.lastDependants = dependants; + } + + node = cache.head; + while (node) { + // Check whether node arguments match arguments + if (!isShallowEqual(node.args, args, 1)) { + node = node.next; + continue; + } + + // At this point we can assume we've found a match + + // Surface matched node to head if not already + if (node !== cache.head) { + // Adjust siblings to point to each other. + /** @type {CacheNode} */ (node.prev).next = node.next; + if (node.next) { + node.next.prev = node.prev; + } + + node.next = cache.head; + node.prev = null; + /** @type {CacheNode} */ (cache.head).prev = node; + cache.head = node; + } + + // Return immediately + return node.val; + } + + // No cached value found. Continue to insertion phase: + + node = /** @type {CacheNode} */ ({ + // Generate the result from original function + val: selector.apply(null, args), + }); + + // Avoid including the source object in the cache. + args[0] = null; + node.args = args; + + // Don't need to check whether node is already head, since it would + // have been returned above already if it was + + // Shift existing head down list + if (cache.head) { + cache.head.prev = node; + node.next = cache.head; + } + + cache.head = node; + + return node.val; + } + + callSelector.getDependants = normalizedGetDependants; + callSelector.clear = clear; + clear(); + + return /** @type {S & EnhancedSelector} */ (callSelector); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/selectors.js +/** + * External dependencies + */ + + +/** + * An object containing information about a guide. + * + * @typedef {Object} NUXGuideInfo + * @property {string[]} tipIds Which tips the guide contains. + * @property {?string} currentTipId The guide's currently showing tip. + * @property {?string} nextTipId The guide's next tip to show. + */ + +/** + * Returns an object describing the guide, if any, that the given tip is a part + * of. + * + * @param {Object} state Global application state. + * @param {string} tipId The tip to query. + * + * @return {?NUXGuideInfo} Information about the associated guide. + */ +const getAssociatedGuide = rememo((state, tipId) => { + for (const tipIds of state.guides) { + if (tipIds.includes(tipId)) { + const nonDismissedTips = tipIds.filter(tId => !Object.keys(state.preferences.dismissedTips).includes(tId)); + const [currentTipId = null, nextTipId = null] = nonDismissedTips; + return { + tipIds, + currentTipId, + nextTipId + }; + } + } + return null; +}, state => [state.guides, state.preferences.dismissedTips]); + +/** + * Determines whether or not the given tip is showing. Tips are hidden if they + * are disabled, have been dismissed, or are not the current tip in any + * guide that they have been added to. + * + * @param {Object} state Global application state. + * @param {string} tipId The tip to query. + * + * @return {boolean} Whether or not the given tip is showing. + */ +function isTipVisible(state, tipId) { + if (!state.preferences.areTipsEnabled) { + return false; + } + if (state.preferences.dismissedTips?.hasOwnProperty(tipId)) { + return false; + } + const associatedGuide = getAssociatedGuide(state, tipId); + if (associatedGuide && associatedGuide.currentTipId !== tipId) { + return false; + } + return true; +} + +/** + * Returns whether or not tips are globally enabled. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether tips are globally enabled. + */ +function selectors_areTipsEnabled(state) { + return state.preferences.areTipsEnabled; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/index.js +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + +const STORE_NAME = 'core/nux'; + +/** + * Store definition for the nux namespace. + * + * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore + * + * @type {Object} + */ +const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, { + reducer: reducer, + actions: actions_namespaceObject, + selectors: selectors_namespaceObject, + persist: ['preferences'] +}); + +// Once we build a more generic persistence plugin that works across types of stores +// we'd be able to replace this with a register call. +(0,external_wp_data_namespaceObject.registerStore)(STORE_NAME, { + reducer: reducer, + actions: actions_namespaceObject, + selectors: selectors_namespaceObject, + persist: ['preferences'] +}); + +;// CONCATENATED MODULE: external ["wp","element"] +var external_wp_element_namespaceObject = window["wp"]["element"]; +;// CONCATENATED MODULE: external ["wp","compose"] +var external_wp_compose_namespaceObject = window["wp"]["compose"]; +;// CONCATENATED MODULE: external ["wp","components"] +var external_wp_components_namespaceObject = window["wp"]["components"]; +;// CONCATENATED MODULE: external ["wp","i18n"] +var external_wp_i18n_namespaceObject = window["wp"]["i18n"]; +;// CONCATENATED MODULE: external ["wp","primitives"] +var external_wp_primitives_namespaceObject = window["wp"]["primitives"]; +;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close.js + +/** + * WordPress dependencies + */ + +const close_close = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24" +}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, { + d: "M13 11.8l6.1-6.3-1-1-6.1 6.2-6.1-6.2-1 1 6.1 6.3-6.5 6.7 1 1 6.5-6.6 6.5 6.6 1-1z" +})); +/* harmony default export */ var library_close = (close_close); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/components/dot-tip/index.js + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + +function onClick(event) { + // Tips are often nested within buttons. We stop propagation so that clicking + // on a tip doesn't result in the button being clicked. + event.stopPropagation(); +} +function DotTip({ + position = 'middle right', + children, + isVisible, + hasNextTip, + onDismiss, + onDisable +}) { + const anchorParent = (0,external_wp_element_namespaceObject.useRef)(null); + const onFocusOutsideCallback = (0,external_wp_element_namespaceObject.useCallback)(event => { + if (!anchorParent.current) { + return; + } + if (anchorParent.current.contains(event.relatedTarget)) { + return; + } + onDisable(); + }, [onDisable, anchorParent]); + if (!isVisible) { + return null; + } + return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Popover, { + className: "nux-dot-tip", + position: position, + focusOnMount: true, + role: "dialog", + "aria-label": (0,external_wp_i18n_namespaceObject.__)('Editor tips'), + onClick: onClick, + onFocusOutside: onFocusOutsideCallback + }, (0,external_wp_element_namespaceObject.createElement)("p", null, children), (0,external_wp_element_namespaceObject.createElement)("p", null, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, { + variant: "link", + onClick: onDismiss + }, hasNextTip ? (0,external_wp_i18n_namespaceObject.__)('See next tip') : (0,external_wp_i18n_namespaceObject.__)('Got it'))), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, { + className: "nux-dot-tip__disable", + icon: library_close, + label: (0,external_wp_i18n_namespaceObject.__)('Disable tips'), + onClick: onDisable + })); +} +/* harmony default export */ var dot_tip = ((0,external_wp_compose_namespaceObject.compose)((0,external_wp_data_namespaceObject.withSelect)((select, { + tipId +}) => { + const { + isTipVisible, + getAssociatedGuide + } = select(store); + const associatedGuide = getAssociatedGuide(tipId); + return { + isVisible: isTipVisible(tipId), + hasNextTip: !!(associatedGuide && associatedGuide.nextTipId) + }; +}), (0,external_wp_data_namespaceObject.withDispatch)((dispatch, { + tipId +}) => { + const { + dismissTip, + disableTips + } = dispatch(store); + return { + onDismiss() { + dismissTip(tipId); + }, + onDisable() { + disableTips(); + } + }; +}))(DotTip)); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/index.js +/** + * WordPress dependencies + */ + + + +external_wp_deprecated_default()('wp.nux', { + since: '5.4', + hint: 'wp.components.Guide can be used to show a user guide.', + version: '6.2' +}); + +(window.wp = window.wp || {}).nux = __webpack_exports__; +/******/ })() +;
\ No newline at end of file |