You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
993 lines
28 KiB
993 lines
28 KiB
this["wp"] = this["wp"] || {}; this["wp"]["nux"] = |
|
/******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) { |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ i: moduleId, |
|
/******/ l: false, |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.l = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // define getter function for harmony exports |
|
/******/ __webpack_require__.d = function(exports, name, getter) { |
|
/******/ if(!__webpack_require__.o(exports, name)) { |
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
|
/******/ } |
|
/******/ }; |
|
/******/ |
|
/******/ // 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 }); |
|
/******/ }; |
|
/******/ |
|
/******/ // create a fake namespace object |
|
/******/ // mode & 1: value is a module id, require it |
|
/******/ // mode & 2: merge all properties of value into the ns |
|
/******/ // mode & 4: return value when already ns object |
|
/******/ // mode & 8|1: behave like require |
|
/******/ __webpack_require__.t = function(value, mode) { |
|
/******/ if(mode & 1) value = __webpack_require__(value); |
|
/******/ if(mode & 8) return value; |
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
|
/******/ var ns = Object.create(null); |
|
/******/ __webpack_require__.r(ns); |
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
|
/******/ return ns; |
|
/******/ }; |
|
/******/ |
|
/******/ // getDefaultExport function for compatibility with non-harmony modules |
|
/******/ __webpack_require__.n = function(module) { |
|
/******/ var getter = module && module.__esModule ? |
|
/******/ function getDefault() { return module['default']; } : |
|
/******/ function getModuleExports() { return module; }; |
|
/******/ __webpack_require__.d(getter, 'a', getter); |
|
/******/ return getter; |
|
/******/ }; |
|
/******/ |
|
/******/ // Object.prototype.hasOwnProperty.call |
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(__webpack_require__.s = 320); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ({ |
|
|
|
/***/ 0: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["element"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 1: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["i18n"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 15: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); |
|
function _defineProperty(obj, key, value) { |
|
if (key in obj) { |
|
Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: true, |
|
configurable: true, |
|
writable: true |
|
}); |
|
} else { |
|
obj[key] = value; |
|
} |
|
|
|
return obj; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 19: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js |
|
function _arrayWithoutHoles(arr) { |
|
if (Array.isArray(arr)) { |
|
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { |
|
arr2[i] = arr[i]; |
|
} |
|
|
|
return arr2; |
|
} |
|
} |
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js |
|
var iterableToArray = __webpack_require__(33); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js |
|
function _nonIterableSpread() { |
|
throw new TypeError("Invalid attempt to spread non-iterable instance"); |
|
} |
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; }); |
|
|
|
|
|
|
|
function _toConsumableArray(arr) { |
|
return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread(); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 2: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["lodash"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 25: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js |
|
var arrayWithHoles = __webpack_require__(35); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js |
|
function _iterableToArrayLimit(arr, i) { |
|
var _arr = []; |
|
var _n = true; |
|
var _d = false; |
|
var _e = undefined; |
|
|
|
try { |
|
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { |
|
_arr.push(_s.value); |
|
|
|
if (i && _arr.length === i) break; |
|
} |
|
} catch (err) { |
|
_d = true; |
|
_e = err; |
|
} finally { |
|
try { |
|
if (!_n && _i["return"] != null) _i["return"](); |
|
} finally { |
|
if (_d) throw _e; |
|
} |
|
} |
|
|
|
return _arr; |
|
} |
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js |
|
var nonIterableRest = __webpack_require__(36); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; }); |
|
|
|
|
|
|
|
function _slicedToArray(arr, i) { |
|
return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])(); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 31: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
|
|
var LEAF_KEY, hasWeakMap; |
|
|
|
/** |
|
* Arbitrary value used as key for referencing cache object in WeakMap tree. |
|
* |
|
* @type {Object} |
|
*/ |
|
LEAF_KEY = {}; |
|
|
|
/** |
|
* Whether environment supports WeakMap. |
|
* |
|
* @type {boolean} |
|
*/ |
|
hasWeakMap = typeof WeakMap !== 'undefined'; |
|
|
|
/** |
|
* Returns the first argument as the sole entry in an array. |
|
* |
|
* @param {*} value Value to return. |
|
* |
|
* @return {Array} 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 {Object} Cache object. |
|
*/ |
|
function createCache() { |
|
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 {Array} a First array. |
|
* @param {Array} 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. |
|
* |
|
* @param {Function} selector Selector function. |
|
* @param {Function} getDependants Dependant getter returning an immutable |
|
* reference or array of reference used in |
|
* cache bust consideration. |
|
* |
|
* @return {Function} Memoized selector. |
|
*/ |
|
/* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) { |
|
var rootCache, getCache; |
|
|
|
// Use object source as dependant if getter not provided |
|
if ( ! getDependants ) { |
|
getDependants = arrayOf; |
|
} |
|
|
|
/** |
|
* Returns the root cache. If WeakMap is supported, this is assigned to the |
|
* root WeakMap cache set, otherwise it is a shared instance of the default |
|
* cache object. |
|
* |
|
* @return {(WeakMap|Object)} Root cache object. |
|
*/ |
|
function getRootCache() { |
|
return rootCache; |
|
} |
|
|
|
/** |
|
* 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 {Array} dependants Selector dependants. |
|
* |
|
* @return {Object} Cache object. |
|
*/ |
|
function getWeakMapCache( 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 ); |
|
} |
|
|
|
// Assign cache handler by availability of WeakMap |
|
getCache = hasWeakMap ? getWeakMapCache : getRootCache; |
|
|
|
/** |
|
* Resets root memoization cache. |
|
*/ |
|
function clear() { |
|
rootCache = hasWeakMap ? new WeakMap() : createCache(); |
|
} |
|
|
|
// eslint-disable-next-line jsdoc/check-param-names |
|
/** |
|
* The augmented selector call, considering first whether dependants have |
|
* changed before passing it to underlying memoize function. |
|
* |
|
* @param {Object} source Source object for derivation. |
|
* @param {...*} extraArgs Additional arguments to pass to selector. |
|
* |
|
* @return {*} Selector result. |
|
*/ |
|
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 = getDependants.apply( null, args ); |
|
cache = getCache( dependants ); |
|
|
|
// If not guaranteed uniqueness by dependants (primitive type or lack |
|
// of WeakMap support), 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. |
|
node.prev.next = node.next; |
|
if ( node.next ) { |
|
node.next.prev = node.prev; |
|
} |
|
|
|
node.next = cache.head; |
|
node.prev = null; |
|
cache.head.prev = node; |
|
cache.head = node; |
|
} |
|
|
|
// Return immediately |
|
return node.val; |
|
} |
|
|
|
// No cached value found. Continue to insertion phase: |
|
|
|
node = { |
|
// 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 = getDependants; |
|
callSelector.clear = clear; |
|
clear(); |
|
|
|
return callSelector; |
|
}); |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 320: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
var actions_namespaceObject = {}; |
|
__webpack_require__.r(actions_namespaceObject); |
|
__webpack_require__.d(actions_namespaceObject, "triggerGuide", function() { return triggerGuide; }); |
|
__webpack_require__.d(actions_namespaceObject, "dismissTip", function() { return dismissTip; }); |
|
__webpack_require__.d(actions_namespaceObject, "disableTips", function() { return disableTips; }); |
|
__webpack_require__.d(actions_namespaceObject, "enableTips", function() { return enableTips; }); |
|
var selectors_namespaceObject = {}; |
|
__webpack_require__.r(selectors_namespaceObject); |
|
__webpack_require__.d(selectors_namespaceObject, "getAssociatedGuide", function() { return getAssociatedGuide; }); |
|
__webpack_require__.d(selectors_namespaceObject, "isTipVisible", function() { return isTipVisible; }); |
|
__webpack_require__.d(selectors_namespaceObject, "areTipsEnabled", function() { return selectors_areTipsEnabled; }); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","data"]} |
|
var external_this_wp_data_ = __webpack_require__(5); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js |
|
var defineProperty = __webpack_require__(15); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js |
|
var objectSpread = __webpack_require__(8); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules |
|
var toConsumableArray = __webpack_require__(19); |
|
|
|
// 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() { |
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; |
|
var action = arguments.length > 1 ? arguments[1] : undefined; |
|
|
|
switch (action.type) { |
|
case 'TRIGGER_GUIDE': |
|
return Object(toConsumableArray["a" /* default */])(state).concat([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() { |
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; |
|
var action = arguments.length > 1 ? arguments[1] : undefined; |
|
|
|
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() { |
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; |
|
var action = arguments.length > 1 ? arguments[1] : undefined; |
|
|
|
switch (action.type) { |
|
case 'DISMISS_TIP': |
|
return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.id, true)); |
|
|
|
case 'ENABLE_TIPS': |
|
return {}; |
|
} |
|
|
|
return state; |
|
} |
|
var preferences = Object(external_this_wp_data_["combineReducers"])({ |
|
areTipsEnabled: areTipsEnabled, |
|
dismissedTips: dismissedTips |
|
}); |
|
/* harmony default export */ var reducer = (Object(external_this_wp_data_["combineReducers"])({ |
|
guides: guides, |
|
preferences: 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: 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: 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' |
|
}; |
|
} |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules |
|
var slicedToArray = __webpack_require__(25); |
|
|
|
// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js |
|
var rememo = __webpack_require__(31); |
|
|
|
// EXTERNAL MODULE: external "lodash" |
|
var external_lodash_ = __webpack_require__(2); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/selectors.js |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* An object containing information about a guide. |
|
* |
|
* @typedef {Object} NUX.GuideInfo |
|
* @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 {?NUX.GuideInfo} Information about the associated guide. |
|
*/ |
|
|
|
var getAssociatedGuide = Object(rememo["a" /* default */])(function (state, tipId) { |
|
var _iteratorNormalCompletion = true; |
|
var _didIteratorError = false; |
|
var _iteratorError = undefined; |
|
|
|
try { |
|
for (var _iterator = state.guides[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { |
|
var tipIds = _step.value; |
|
|
|
if (Object(external_lodash_["includes"])(tipIds, tipId)) { |
|
var nonDismissedTips = Object(external_lodash_["difference"])(tipIds, Object(external_lodash_["keys"])(state.preferences.dismissedTips)); |
|
|
|
var _nonDismissedTips = Object(slicedToArray["a" /* default */])(nonDismissedTips, 2), |
|
_nonDismissedTips$ = _nonDismissedTips[0], |
|
currentTipId = _nonDismissedTips$ === void 0 ? null : _nonDismissedTips$, |
|
_nonDismissedTips$2 = _nonDismissedTips[1], |
|
nextTipId = _nonDismissedTips$2 === void 0 ? null : _nonDismissedTips$2; |
|
|
|
return { |
|
tipIds: tipIds, |
|
currentTipId: currentTipId, |
|
nextTipId: nextTipId |
|
}; |
|
} |
|
} |
|
} catch (err) { |
|
_didIteratorError = true; |
|
_iteratorError = err; |
|
} finally { |
|
try { |
|
if (!_iteratorNormalCompletion && _iterator.return != null) { |
|
_iterator.return(); |
|
} |
|
} finally { |
|
if (_didIteratorError) { |
|
throw _iteratorError; |
|
} |
|
} |
|
} |
|
|
|
return null; |
|
}, function (state) { |
|
return [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[tipId]) { |
|
return false; |
|
} |
|
|
|
var 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 |
|
*/ |
|
|
|
|
|
|
|
|
|
var store = Object(external_this_wp_data_["registerStore"])('core/nux', { |
|
reducer: reducer, |
|
actions: actions_namespaceObject, |
|
selectors: selectors_namespaceObject, |
|
persist: ['preferences'] |
|
}); |
|
/* harmony default export */ var build_module_store = (store); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","element"]} |
|
var external_this_wp_element_ = __webpack_require__(0); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","compose"]} |
|
var external_this_wp_compose_ = __webpack_require__(7); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","components"]} |
|
var external_this_wp_components_ = __webpack_require__(4); |
|
|
|
// EXTERNAL MODULE: external {"this":["wp","i18n"]} |
|
var external_this_wp_i18n_ = __webpack_require__(1); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/components/dot-tip/index.js |
|
|
|
|
|
/** |
|
* WordPress dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
function getAnchorRect(anchor) { |
|
// The default getAnchorRect() excludes an element's top and bottom padding |
|
// from its calculation. We want tips to point to the outer margin of an |
|
// element, so we override getAnchorRect() to include all padding. |
|
return anchor.parentNode.getBoundingClientRect(); |
|
} |
|
|
|
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(_ref) { |
|
var children = _ref.children, |
|
isVisible = _ref.isVisible, |
|
hasNextTip = _ref.hasNextTip, |
|
onDismiss = _ref.onDismiss, |
|
onDisable = _ref.onDisable; |
|
|
|
if (!isVisible) { |
|
return null; |
|
} |
|
|
|
return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Popover"], { |
|
className: "nux-dot-tip", |
|
position: "middle right", |
|
noArrow: true, |
|
focusOnMount: "container", |
|
getAnchorRect: getAnchorRect, |
|
role: "dialog", |
|
"aria-label": Object(external_this_wp_i18n_["__"])('Editor tips'), |
|
onClick: onClick |
|
}, Object(external_this_wp_element_["createElement"])("p", null, children), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { |
|
isLink: true, |
|
onClick: onDismiss |
|
}, hasNextTip ? Object(external_this_wp_i18n_["__"])('See next tip') : Object(external_this_wp_i18n_["__"])('Got it'))), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { |
|
className: "nux-dot-tip__disable", |
|
icon: "no-alt", |
|
label: Object(external_this_wp_i18n_["__"])('Disable tips'), |
|
onClick: onDisable |
|
})); |
|
} |
|
/* harmony default export */ var dot_tip = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { |
|
var tipId = _ref2.tipId; |
|
|
|
var _select = select('core/nux'), |
|
isTipVisible = _select.isTipVisible, |
|
getAssociatedGuide = _select.getAssociatedGuide; |
|
|
|
var associatedGuide = getAssociatedGuide(tipId); |
|
return { |
|
isVisible: isTipVisible(tipId), |
|
hasNextTip: !!(associatedGuide && associatedGuide.nextTipId) |
|
}; |
|
}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref3) { |
|
var tipId = _ref3.tipId; |
|
|
|
var _dispatch = dispatch('core/nux'), |
|
dismissTip = _dispatch.dismissTip, |
|
disableTips = _dispatch.disableTips; |
|
|
|
return { |
|
onDismiss: function onDismiss() { |
|
dismissTip(tipId); |
|
}, |
|
onDisable: function onDisable() { |
|
disableTips(); |
|
} |
|
}; |
|
}))(DotTip)); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/index.js |
|
/* concated harmony reexport DotTip */__webpack_require__.d(__webpack_exports__, "DotTip", function() { return dot_tip; }); |
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 33: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); |
|
function _iterableToArray(iter) { |
|
if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 35: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); |
|
function _arrayWithHoles(arr) { |
|
if (Array.isArray(arr)) return arr; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 36: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); |
|
function _nonIterableRest() { |
|
throw new TypeError("Invalid attempt to destructure non-iterable instance"); |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 4: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["components"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 5: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["data"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 7: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["wp"]["compose"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 8: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; }); |
|
/* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15); |
|
|
|
function _objectSpread(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i] != null ? arguments[i] : {}; |
|
var ownKeys = Object.keys(source); |
|
|
|
if (typeof Object.getOwnPropertySymbols === 'function') { |
|
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { |
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable; |
|
})); |
|
} |
|
|
|
ownKeys.forEach(function (key) { |
|
Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); |
|
}); |
|
} |
|
|
|
return target; |
|
} |
|
|
|
/***/ }) |
|
|
|
/******/ }); |