mirror of
https://github.com/WordPress/WordPress.git
synced 2024-11-05 10:22:23 +01:00
067856838b
Merges [48719] to the 5.5 branch. Fixes #50841. Built from https://develop.svn.wordpress.org/branches/5.5@48720 git-svn-id: http://core.svn.wordpress.org/branches/5.5@48482 1a063a9b-81f0-0310-95a4-ce76da25c4cd
936 lines
29 KiB
JavaScript
936 lines
29 KiB
JavaScript
this["wp"] = this["wp"] || {}; this["wp"]["keyboardShortcuts"] =
|
|
/******/ (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 = 456);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ({
|
|
|
|
/***/ 14:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
|
|
var arrayWithHoles = __webpack_require__(38);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
|
|
function _iterableToArrayLimit(arr, i) {
|
|
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
|
|
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/unsupportedIterableToArray.js
|
|
var unsupportedIterableToArray = __webpack_require__(29);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
|
|
var nonIterableRest = __webpack_require__(39);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
|
|
|
|
|
|
|
|
|
|
function _slicedToArray(arr, i) {
|
|
return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 18:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
|
|
var arrayLikeToArray = __webpack_require__(26);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
|
|
|
|
function _arrayWithoutHoles(arr) {
|
|
if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
|
|
var iterableToArray = __webpack_require__(35);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
|
|
var unsupportedIterableToArray = __webpack_require__(29);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
|
|
function _nonIterableSpread() {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
|
|
|
|
|
|
|
|
|
|
function _toConsumableArray(arr) {
|
|
return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["lodash"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 21:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["wp"]["keycodes"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length) len = arr.length;
|
|
|
|
for (var i = 0, arr2 = new Array(len); i < len; i++) {
|
|
arr2[i] = arr[i];
|
|
}
|
|
|
|
return arr2;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 29:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
|
|
/* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26);
|
|
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
if (n === "Map" || n === "Set") return Array.from(o);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 35:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
|
|
function _iterableToArray(iter) {
|
|
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 38:
|
|
/***/ (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;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 39:
|
|
/***/ (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.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["wp"]["data"]; }());
|
|
|
|
/***/ }),
|
|
|
|
/***/ 42:
|
|
/***/ (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;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 456:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// ESM COMPAT FLAG
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, "useShortcut", function() { return /* reexport */ use_shortcut; });
|
|
|
|
// NAMESPACE OBJECT: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/actions.js
|
|
var actions_namespaceObject = {};
|
|
__webpack_require__.r(actions_namespaceObject);
|
|
__webpack_require__.d(actions_namespaceObject, "registerShortcut", function() { return registerShortcut; });
|
|
__webpack_require__.d(actions_namespaceObject, "unregisterShortcut", function() { return unregisterShortcut; });
|
|
|
|
// NAMESPACE OBJECT: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/selectors.js
|
|
var selectors_namespaceObject = {};
|
|
__webpack_require__.r(selectors_namespaceObject);
|
|
__webpack_require__.d(selectors_namespaceObject, "getShortcutKeyCombination", function() { return getShortcutKeyCombination; });
|
|
__webpack_require__.d(selectors_namespaceObject, "getShortcutRepresentation", function() { return getShortcutRepresentation; });
|
|
__webpack_require__.d(selectors_namespaceObject, "getShortcutDescription", function() { return getShortcutDescription; });
|
|
__webpack_require__.d(selectors_namespaceObject, "getShortcutAliases", function() { return getShortcutAliases; });
|
|
__webpack_require__.d(selectors_namespaceObject, "getAllShortcutRawKeyCombinations", function() { return getAllShortcutRawKeyCombinations; });
|
|
__webpack_require__.d(selectors_namespaceObject, "getCategoryShortcuts", function() { return getCategoryShortcuts; });
|
|
|
|
// EXTERNAL MODULE: external {"this":["wp","data"]}
|
|
var external_this_wp_data_ = __webpack_require__(4);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(5);
|
|
|
|
// EXTERNAL MODULE: external {"this":"lodash"}
|
|
var external_this_lodash_ = __webpack_require__(2);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/reducer.js
|
|
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
/**
|
|
* External dependencies
|
|
*/
|
|
|
|
/**
|
|
* Reducer returning the registered shortcuts
|
|
*
|
|
* @param {Object} state Current state.
|
|
* @param {Object} action Dispatched action.
|
|
*
|
|
* @return {Object} Updated state.
|
|
*/
|
|
|
|
function reducer() {
|
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
var action = arguments.length > 1 ? arguments[1] : undefined;
|
|
|
|
switch (action.type) {
|
|
case 'REGISTER_SHORTCUT':
|
|
return _objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.name, {
|
|
category: action.category,
|
|
keyCombination: action.keyCombination,
|
|
aliases: action.aliases,
|
|
description: action.description
|
|
}));
|
|
|
|
case 'UNREGISTER_SHORTCUT':
|
|
return Object(external_this_lodash_["omit"])(state, action.name);
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
/* harmony default export */ var store_reducer = (reducer);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/actions.js
|
|
/** @typedef {import('@wordpress/keycodes').WPKeycodeModifier} WPKeycodeModifier */
|
|
|
|
/**
|
|
* Keyboard key combination.
|
|
*
|
|
* @typedef {Object} WPShortcutKeyCombination
|
|
*
|
|
* @property {string} character Character.
|
|
* @property {WPKeycodeModifier|undefined} modifier Modifier.
|
|
*/
|
|
|
|
/**
|
|
* Configuration of a registered keyboard shortcut.
|
|
*
|
|
* @typedef {Object} WPShortcutConfig
|
|
*
|
|
* @property {string} name Shortcut name.
|
|
* @property {string} category Shortcut category.
|
|
* @property {string} description Shortcut description.
|
|
* @property {WPShortcutKeyCombination} keyCombination Shortcut key combination.
|
|
* @property {WPShortcutKeyCombination[]} [aliases] Shortcut aliases.
|
|
*/
|
|
|
|
/**
|
|
* Returns an action object used to register a new keyboard shortcut.
|
|
*
|
|
* @param {WPShortcutConfig} config Shortcut config.
|
|
*
|
|
* @return {Object} action.
|
|
*/
|
|
function registerShortcut(_ref) {
|
|
var name = _ref.name,
|
|
category = _ref.category,
|
|
description = _ref.description,
|
|
keyCombination = _ref.keyCombination,
|
|
aliases = _ref.aliases;
|
|
return {
|
|
type: 'REGISTER_SHORTCUT',
|
|
name: name,
|
|
category: category,
|
|
keyCombination: keyCombination,
|
|
aliases: aliases,
|
|
description: description
|
|
};
|
|
}
|
|
/**
|
|
* Returns an action object used to unregister a keyboard shortcut.
|
|
*
|
|
* @param {string} name Shortcut name.
|
|
*
|
|
* @return {Object} action.
|
|
*/
|
|
|
|
function unregisterShortcut(name) {
|
|
return {
|
|
type: 'UNREGISTER_SHORTCUT',
|
|
name: name
|
|
};
|
|
}
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(14);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(18);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
|
|
var rememo = __webpack_require__(42);
|
|
|
|
// EXTERNAL MODULE: external {"this":["wp","keycodes"]}
|
|
var external_this_wp_keycodes_ = __webpack_require__(21);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/selectors.js
|
|
|
|
|
|
|
|
/**
|
|
* External dependencies
|
|
*/
|
|
|
|
|
|
/**
|
|
* WordPress dependencies
|
|
*/
|
|
|
|
|
|
/** @typedef {import('./actions').WPShortcutKeyCombination} WPShortcutKeyCombination */
|
|
|
|
/** @typedef {import('@wordpress/keycodes').WPKeycodeHandlerByModifier} WPKeycodeHandlerByModifier */
|
|
|
|
/**
|
|
* Shared reference to an empty array for cases where it is important to avoid
|
|
* returning a new array reference on every invocation.
|
|
*
|
|
* @type {Array<any>}
|
|
*/
|
|
|
|
var EMPTY_ARRAY = [];
|
|
/**
|
|
* Shortcut formatting methods.
|
|
*
|
|
* @property {WPKeycodeHandlerByModifier} display Display formatting.
|
|
* @property {WPKeycodeHandlerByModifier} rawShortcut Raw shortcut formatting.
|
|
* @property {WPKeycodeHandlerByModifier} ariaLabel ARIA label formatting.
|
|
*/
|
|
|
|
var FORMATTING_METHODS = {
|
|
display: external_this_wp_keycodes_["displayShortcut"],
|
|
raw: external_this_wp_keycodes_["rawShortcut"],
|
|
ariaLabel: external_this_wp_keycodes_["shortcutAriaLabel"]
|
|
};
|
|
/**
|
|
* Returns a string representing the key combination.
|
|
*
|
|
* @param {?WPShortcutKeyCombination} shortcut Key combination.
|
|
* @param {keyof FORMATTING_METHODS} representation Type of representation
|
|
* (display, raw, ariaLabel).
|
|
*
|
|
* @return {string?} Shortcut representation.
|
|
*/
|
|
|
|
function getKeyCombinationRepresentation(shortcut, representation) {
|
|
if (!shortcut) {
|
|
return null;
|
|
}
|
|
|
|
return shortcut.modifier ? FORMATTING_METHODS[representation][shortcut.modifier](shortcut.character) : shortcut.character;
|
|
}
|
|
/**
|
|
* Returns the main key combination for a given shortcut name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Shortcut name.
|
|
*
|
|
* @return {WPShortcutKeyCombination?} Key combination.
|
|
*/
|
|
|
|
|
|
function getShortcutKeyCombination(state, name) {
|
|
return state[name] ? state[name].keyCombination : null;
|
|
}
|
|
/**
|
|
* Returns a string representing the main key combination for a given shortcut name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Shortcut name.
|
|
* @param {keyof FORMATTING_METHODS} representation Type of representation
|
|
* (display, raw, ariaLabel).
|
|
*
|
|
* @return {string?} Shortcut representation.
|
|
*/
|
|
|
|
function getShortcutRepresentation(state, name) {
|
|
var representation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'display';
|
|
var shortcut = getShortcutKeyCombination(state, name);
|
|
return getKeyCombinationRepresentation(shortcut, representation);
|
|
}
|
|
/**
|
|
* Returns the shortcut description given its name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Shortcut name.
|
|
*
|
|
* @return {string?} Shortcut description.
|
|
*/
|
|
|
|
function getShortcutDescription(state, name) {
|
|
return state[name] ? state[name].description : null;
|
|
}
|
|
/**
|
|
* Returns the aliases for a given shortcut name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Shortcut name.
|
|
*
|
|
* @return {WPShortcutKeyCombination[]} Key combinations.
|
|
*/
|
|
|
|
function getShortcutAliases(state, name) {
|
|
return state[name] && state[name].aliases ? state[name].aliases : EMPTY_ARRAY;
|
|
}
|
|
/**
|
|
* Returns the raw representation of all the keyboard combinations of a given shortcut name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Shortcut name.
|
|
*
|
|
* @return {string[]} Shortcuts.
|
|
*/
|
|
|
|
var getAllShortcutRawKeyCombinations = Object(rememo["a" /* default */])(function (state, name) {
|
|
return Object(external_this_lodash_["compact"])([getKeyCombinationRepresentation(getShortcutKeyCombination(state, name), 'raw')].concat(Object(toConsumableArray["a" /* default */])(getShortcutAliases(state, name).map(function (combination) {
|
|
return getKeyCombinationRepresentation(combination, 'raw');
|
|
}))));
|
|
}, function (state, name) {
|
|
return [state[name]];
|
|
});
|
|
/**
|
|
* Returns the shortcut names list for a given category name.
|
|
*
|
|
* @param {Object} state Global state.
|
|
* @param {string} name Category name.
|
|
*
|
|
* @return {string[]} Shortcut names.
|
|
*/
|
|
|
|
var getCategoryShortcuts = Object(rememo["a" /* default */])(function (state, categoryName) {
|
|
return Object.entries(state).filter(function (_ref) {
|
|
var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2),
|
|
shortcut = _ref2[1];
|
|
|
|
return shortcut.category === categoryName;
|
|
}).map(function (_ref3) {
|
|
var _ref4 = Object(slicedToArray["a" /* default */])(_ref3, 1),
|
|
name = _ref4[0];
|
|
|
|
return name;
|
|
});
|
|
}, function (state) {
|
|
return [state];
|
|
});
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/index.js
|
|
/**
|
|
* WordPress dependencies
|
|
*/
|
|
|
|
/**
|
|
* Internal dependencies
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var store = (Object(external_this_wp_data_["registerStore"])('core/keyboard-shortcuts', {
|
|
reducer: store_reducer,
|
|
actions: actions_namespaceObject,
|
|
selectors: selectors_namespaceObject
|
|
}));
|
|
|
|
// EXTERNAL MODULE: external {"this":["wp","compose"]}
|
|
var external_this_wp_compose_ = __webpack_require__(9);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/hooks/use-shortcut.js
|
|
/**
|
|
* WordPress dependencies
|
|
*/
|
|
|
|
|
|
/**
|
|
* Attach a keyboard shortcut handler.
|
|
*
|
|
* @param {string} name Shortcut name.
|
|
* @param {Function} callback Shortcut callback.
|
|
* @param {Object} options Shortcut options.
|
|
*/
|
|
|
|
function useShortcut(name, callback, options) {
|
|
var shortcuts = Object(external_this_wp_data_["useSelect"])(function (select) {
|
|
return select('core/keyboard-shortcuts').getAllShortcutRawKeyCombinations(name);
|
|
}, [name]);
|
|
Object(external_this_wp_compose_["useKeyboardShortcut"])(shortcuts, callback, options);
|
|
}
|
|
|
|
/* harmony default export */ var use_shortcut = (useShortcut);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/index.js
|
|
/**
|
|
* Internal dependencies
|
|
*/
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5:
|
|
/***/ (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;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9:
|
|
/***/ (function(module, exports) {
|
|
|
|
(function() { module.exports = this["wp"]["compose"]; }());
|
|
|
|
/***/ })
|
|
|
|
/******/ }); |