--- a/wp/wp-includes/js/dist/core-data.js Tue Dec 15 15:52:01 2020 +0100
+++ b/wp/wp-includes/js/dist/core-data.js Wed Sep 21 18:19:35 2022 +0200
@@ -82,33 +82,120 @@
/******/
/******/
/******/ // Load entry module and return exports
-/******/ return __webpack_require__(__webpack_require__.s = 447);
+/******/ return __webpack_require__(__webpack_require__.s = "dsJ0");
/******/ })
/************************************************************************/
/******/ ({
-/***/ 0:
+/***/ "1ZqX":
/***/ (function(module, exports) {
-(function() { module.exports = this["wp"]["element"]; }());
+(function() { module.exports = window["wp"]["data"]; }());
+
+/***/ }),
+
+/***/ "51Zz":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["wp"]["dataControls"]; }());
/***/ }),
-/***/ 1:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["wp"]["i18n"]; }());
+/***/ "7Cbv":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/rng.js
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+ // lazy load so that environments that need to polyfill have a chance to do so
+ if (!getRandomValues) {
+ // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+ // find the complete implementation of crypto (msCrypto) on IE11.
+ getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+ if (!getRandomValues) {
+ throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+ }
+ }
+
+ return getRandomValues(rnds8);
+}
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/regex.js
+/* harmony default export */ var regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/validate.js
+
+
+function validate(uuid) {
+ return typeof uuid === 'string' && regex.test(uuid);
+}
+
+/* harmony default export */ var esm_browser_validate = (validate);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/stringify.js
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+var byteToHex = [];
+
+for (var stringify_i = 0; stringify_i < 256; ++stringify_i) {
+ byteToHex.push((stringify_i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr) {
+ var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+ // Note: Be careful editing this code! It's been tuned for performance
+ // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+ var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one
+ // of the following:
+ // - One or more input array values don't map to a hex octet (leading to
+ // "undefined" in the uuid)
+ // - Invalid input values for the RFC `version` or `variant` fields
+
+ if (!esm_browser_validate(uuid)) {
+ throw TypeError('Stringified UUID is invalid');
+ }
+
+ return uuid;
+}
+
+/* harmony default export */ var esm_browser_stringify = (stringify);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/v4.js
+
+
+
+function v4(options, buf, offset) {
+ options = options || {};
+ var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+ rnds[6] = rnds[6] & 0x0f | 0x40;
+ rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+ if (buf) {
+ offset = offset || 0;
+
+ for (var i = 0; i < 16; ++i) {
+ buf[offset + i] = rnds[i];
+ }
+
+ return buf;
+ }
+
+ return esm_browser_stringify(rnds);
+}
+
+/* harmony default export */ var esm_browser_v4 = __webpack_exports__["a"] = (v4);
/***/ }),
-/***/ 10:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["wp"]["blocks"]; }());
-
-/***/ }),
-
-/***/ 126:
+/***/ "FtRg":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -423,209 +510,4597 @@
/***/ }),
-/***/ 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 */])();
-}
+/***/ "GRId":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["wp"]["element"]; }());
+
+/***/ }),
+
+/***/ "HSyU":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["wp"]["blocks"]; }());
/***/ }),
-/***/ 18:
+/***/ "Mmq9":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["wp"]["url"]; }());
+
+/***/ }),
+
+/***/ "YLtl":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["lodash"]; }());
+
+/***/ }),
+
+/***/ "dsJ0":
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
// 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);
+__webpack_require__.d(__webpack_exports__, "store", function() { return /* binding */ build_module_store; });
+__webpack_require__.d(__webpack_exports__, "EntityProvider", function() { return /* reexport */ EntityProvider; });
+__webpack_require__.d(__webpack_exports__, "useEntityId", function() { return /* reexport */ useEntityId; });
+__webpack_require__.d(__webpack_exports__, "useEntityProp", function() { return /* reexport */ useEntityProp; });
+__webpack_require__.d(__webpack_exports__, "useEntityBlockEditor", function() { return /* reexport */ useEntityBlockEditor; });
+__webpack_require__.d(__webpack_exports__, "__experimentalFetchLinkSuggestions", function() { return /* reexport */ _experimental_fetch_link_suggestions; });
+__webpack_require__.d(__webpack_exports__, "__experimentalFetchRemoteUrlData", function() { return /* reexport */ _experimental_fetch_remote_url_data; });
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/locks/actions.js
+var locks_actions_namespaceObject = {};
+__webpack_require__.r(locks_actions_namespaceObject);
+__webpack_require__.d(locks_actions_namespaceObject, "__unstableAcquireStoreLock", function() { return __unstableAcquireStoreLock; });
+__webpack_require__.d(locks_actions_namespaceObject, "__unstableEnqueueLockRequest", function() { return __unstableEnqueueLockRequest; });
+__webpack_require__.d(locks_actions_namespaceObject, "__unstableReleaseStoreLock", function() { return __unstableReleaseStoreLock; });
+__webpack_require__.d(locks_actions_namespaceObject, "__unstableProcessPendingLockRequests", function() { return __unstableProcessPendingLockRequests; });
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/actions.js
+var build_module_actions_namespaceObject = {};
+__webpack_require__.r(build_module_actions_namespaceObject);
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveUserQuery", function() { return receiveUserQuery; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentUser", function() { return receiveCurrentUser; });
+__webpack_require__.d(build_module_actions_namespaceObject, "addEntities", function() { return addEntities; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveEntityRecords", function() { return receiveEntityRecords; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentTheme", function() { return receiveCurrentTheme; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveThemeSupports", function() { return receiveThemeSupports; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveEmbedPreview", function() { return receiveEmbedPreview; });
+__webpack_require__.d(build_module_actions_namespaceObject, "deleteEntityRecord", function() { return deleteEntityRecord; });
+__webpack_require__.d(build_module_actions_namespaceObject, "editEntityRecord", function() { return actions_editEntityRecord; });
+__webpack_require__.d(build_module_actions_namespaceObject, "undo", function() { return undo; });
+__webpack_require__.d(build_module_actions_namespaceObject, "redo", function() { return redo; });
+__webpack_require__.d(build_module_actions_namespaceObject, "__unstableCreateUndoLevel", function() { return actions_unstableCreateUndoLevel; });
+__webpack_require__.d(build_module_actions_namespaceObject, "saveEntityRecord", function() { return saveEntityRecord; });
+__webpack_require__.d(build_module_actions_namespaceObject, "__experimentalBatch", function() { return __experimentalBatch; });
+__webpack_require__.d(build_module_actions_namespaceObject, "saveEditedEntityRecord", function() { return saveEditedEntityRecord; });
+__webpack_require__.d(build_module_actions_namespaceObject, "__experimentalSaveSpecifiedEntityEdits", function() { return __experimentalSaveSpecifiedEntityEdits; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveUploadPermissions", function() { return receiveUploadPermissions; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveUserPermission", function() { return receiveUserPermission; });
+__webpack_require__.d(build_module_actions_namespaceObject, "receiveAutosaves", function() { return receiveAutosaves; });
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/selectors.js
+var build_module_selectors_namespaceObject = {};
+__webpack_require__.r(build_module_selectors_namespaceObject);
+__webpack_require__.d(build_module_selectors_namespaceObject, "isRequestingEmbedPreview", function() { return isRequestingEmbedPreview; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getAuthors", function() { return getAuthors; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "__unstableGetAuthor", function() { return __unstableGetAuthor; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentUser", function() { return getCurrentUser; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getUserQueryResults", function() { return getUserQueryResults; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntitiesByKind", function() { return getEntitiesByKind; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntity", function() { return getEntity; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecord", function() { return getEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetEntityRecordNoResolver", function() { return __experimentalGetEntityRecordNoResolver; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getRawEntityRecord", function() { return getRawEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "hasEntityRecords", function() { return hasEntityRecords; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecords", function() { return getEntityRecords; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetDirtyEntityRecords", function() { return __experimentalGetDirtyEntityRecords; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordEdits", function() { return getEntityRecordEdits; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordNonTransientEdits", function() { return getEntityRecordNonTransientEdits; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "hasEditsForEntityRecord", function() { return hasEditsForEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEditedEntityRecord", function() { return getEditedEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "isAutosavingEntityRecord", function() { return isAutosavingEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "isSavingEntityRecord", function() { return isSavingEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "isDeletingEntityRecord", function() { return isDeletingEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getLastEntitySaveError", function() { return getLastEntitySaveError; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getLastEntityDeleteError", function() { return getLastEntityDeleteError; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getUndoEdit", function() { return getUndoEdit; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getRedoEdit", function() { return getRedoEdit; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "hasUndo", function() { return hasUndo; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "hasRedo", function() { return hasRedo; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentTheme", function() { return getCurrentTheme; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getThemeSupports", function() { return getThemeSupports; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getEmbedPreview", function() { return getEmbedPreview; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "isPreviewEmbedFallback", function() { return isPreviewEmbedFallback; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "canUser", function() { return canUser; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "canUserEditEntityRecord", function() { return canUserEditEntityRecord; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getAutosaves", function() { return getAutosaves; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getAutosave", function() { return getAutosave; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "hasFetchedAutosaves", function() { return hasFetchedAutosaves; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "getReferenceByDistinctEdits", function() { return getReferenceByDistinctEdits; });
+__webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetTemplateForLink", function() { return __experimentalGetTemplateForLink; });
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/resolvers.js
+var resolvers_namespaceObject = {};
+__webpack_require__.r(resolvers_namespaceObject);
+__webpack_require__.d(resolvers_namespaceObject, "getAuthors", function() { return resolvers_getAuthors; });
+__webpack_require__.d(resolvers_namespaceObject, "__unstableGetAuthor", function() { return resolvers_unstableGetAuthor; });
+__webpack_require__.d(resolvers_namespaceObject, "getCurrentUser", function() { return resolvers_getCurrentUser; });
+__webpack_require__.d(resolvers_namespaceObject, "getEntityRecord", function() { return resolvers_getEntityRecord; });
+__webpack_require__.d(resolvers_namespaceObject, "getRawEntityRecord", function() { return resolvers_getRawEntityRecord; });
+__webpack_require__.d(resolvers_namespaceObject, "getEditedEntityRecord", function() { return resolvers_getEditedEntityRecord; });
+__webpack_require__.d(resolvers_namespaceObject, "getEntityRecords", function() { return resolvers_getEntityRecords; });
+__webpack_require__.d(resolvers_namespaceObject, "getCurrentTheme", function() { return resolvers_getCurrentTheme; });
+__webpack_require__.d(resolvers_namespaceObject, "getThemeSupports", function() { return resolvers_getThemeSupports; });
+__webpack_require__.d(resolvers_namespaceObject, "getEmbedPreview", function() { return resolvers_getEmbedPreview; });
+__webpack_require__.d(resolvers_namespaceObject, "canUser", function() { return resolvers_canUser; });
+__webpack_require__.d(resolvers_namespaceObject, "canUserEditEntityRecord", function() { return resolvers_canUserEditEntityRecord; });
+__webpack_require__.d(resolvers_namespaceObject, "getAutosaves", function() { return resolvers_getAutosaves; });
+__webpack_require__.d(resolvers_namespaceObject, "getAutosave", function() { return resolvers_getAutosave; });
+__webpack_require__.d(resolvers_namespaceObject, "__experimentalGetTemplateForLink", function() { return resolvers_experimentalGetTemplateForLink; });
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/locks/selectors.js
+var locks_selectors_namespaceObject = {};
+__webpack_require__.r(locks_selectors_namespaceObject);
+__webpack_require__.d(locks_selectors_namespaceObject, "__unstableGetPendingLockRequests", function() { return __unstableGetPendingLockRequests; });
+__webpack_require__.d(locks_selectors_namespaceObject, "__unstableIsLockAvailable", function() { return __unstableIsLockAvailable; });
+
+// EXTERNAL MODULE: external ["wp","data"]
+var external_wp_data_ = __webpack_require__("1ZqX");
+
+// EXTERNAL MODULE: external ["wp","dataControls"]
+var external_wp_dataControls_ = __webpack_require__("51Zz");
+
+// EXTERNAL MODULE: external "lodash"
+var external_lodash_ = __webpack_require__("YLtl");
+
+// EXTERNAL MODULE: external ["wp","isShallowEqual"]
+var external_wp_isShallowEqual_ = __webpack_require__("rl8x");
+var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js
+/**
+ * A higher-order reducer creator which invokes the original reducer only if
+ * the dispatching action matches the given predicate, **OR** if state is
+ * initializing (undefined).
+ *
+ * @param {Function} isMatch Function predicate for allowing reducer call.
+ *
+ * @return {Function} Higher-order reducer.
+ */
+const ifMatchingAction = isMatch => reducer => (state, action) => {
+ if (state === undefined || isMatch(action)) {
+ return reducer(state, action);
+ }
+
+ return state;
+};
+
+/* harmony default export */ var if_matching_action = (ifMatchingAction);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js
+/**
+ * Higher-order reducer creator which substitutes the action object before
+ * passing to the original reducer.
+ *
+ * @param {Function} replacer Function mapping original action to replacement.
+ *
+ * @return {Function} Higher-order reducer.
+ */
+const replaceAction = replacer => reducer => (state, action) => {
+ return reducer(state, replacer(action));
+};
+
+/* harmony default export */ var replace_action = (replaceAction);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/conservative-map-item.js
+/**
+ * External dependencies
+ */
+
+/**
+ * Given the current and next item entity, returns the minimally "modified"
+ * result of the next item, preferring value references from the original item
+ * if equal. If all values match, the original item is returned.
+ *
+ * @param {Object} item Original item.
+ * @param {Object} nextItem Next item.
+ *
+ * @return {Object} Minimally modified merged item.
+ */
+
+function conservativeMapItem(item, nextItem) {
+ // Return next item in its entirety if there is no original item.
+ if (!item) {
+ return nextItem;
+ }
+
+ let hasChanges = false;
+ const result = {};
+
+ for (const key in nextItem) {
+ if (Object(external_lodash_["isEqual"])(item[key], nextItem[key])) {
+ result[key] = item[key];
+ } else {
+ hasChanges = true;
+ result[key] = nextItem[key];
+ }
+ }
+
+ if (!hasChanges) {
+ return item;
+ } // Only at this point, backfill properties from the original item which
+ // weren't explicitly set into the result above. This is an optimization
+ // to allow `hasChanges` to return early.
+
+
+ for (const key in item) {
+ if (!result.hasOwnProperty(key)) {
+ result[key] = item[key];
+ }
+ }
+
+ return result;
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.js
+/**
+ * Higher-order reducer creator which creates a combined reducer object, keyed
+ * by a property on the action object.
+ *
+ * @param {string} actionProperty Action property by which to key object.
+ *
+ * @return {Function} Higher-order reducer.
+ */
+const onSubKey = actionProperty => reducer => (state = {}, action) => {
+ // Retrieve subkey from action. Do not track if undefined; useful for cases
+ // where reducer is scoped by action shape.
+ const key = action[actionProperty];
+
+ if (key === undefined) {
+ return state;
+ } // Avoid updating state if unchanged. Note that this also accounts for a
+ // reducer which returns undefined on a key which is not yet tracked.
+
+
+ const nextKeyState = reducer(state[key], action);
+
+ if (nextKeyState === state[key]) {
+ return state;
+ }
+
+ return { ...state,
+ [key]: nextKeyState
+ };
+};
+/* harmony default export */ var on_sub_key = (onSubKey);
+
+// EXTERNAL MODULE: external ["wp","i18n"]
+var external_wp_i18n_ = __webpack_require__("l3Sj");
+
+// EXTERNAL MODULE: ./node_modules/uuid/dist/esm-browser/v4.js + 4 modules
+var v4 = __webpack_require__("7Cbv");
+
+// EXTERNAL MODULE: external ["wp","url"]
+var external_wp_url_ = __webpack_require__("Mmq9");
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js
+/**
+ * External dependencies
+ */
+
+/**
+ * Returns an action object used in signalling that items have been received.
+ *
+ * @param {Array} items Items received.
+ * @param {?Object} edits Optional edits to reset.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveItems(items, edits) {
+ return {
+ type: 'RECEIVE_ITEMS',
+ items: Object(external_lodash_["castArray"])(items),
+ persistedEdits: edits
+ };
+}
+/**
+ * Returns an action object used in signalling that entity records have been
+ * deleted and they need to be removed from entities state.
+ *
+ * @param {string} kind Kind of the removed entities.
+ * @param {string} name Name of the removed entities.
+ * @param {Array|number} records Record IDs of the removed entities.
+ * @param {boolean} invalidateCache Controls whether we want to invalidate the cache.
+ * @return {Object} Action object.
+ */
+
+function removeItems(kind, name, records, invalidateCache = false) {
+ return {
+ type: 'REMOVE_ITEMS',
+ itemIds: Object(external_lodash_["castArray"])(records),
+ kind,
+ name,
+ invalidateCache
+ };
+}
+/**
+ * Returns an action object used in signalling that queried data has been
+ * received.
+ *
+ * @param {Array} items Queried items received.
+ * @param {?Object} query Optional query object.
+ * @param {?Object} edits Optional edits to reset.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveQueriedItems(items, query = {}, edits) {
+ return { ...receiveItems(items, edits),
+ query
+ };
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/locks/actions.js
+/**
+ * WordPress dependencies
+ */
+
+
+function* __unstableAcquireStoreLock(store, path, {
+ exclusive
+}) {
+ const promise = yield* __unstableEnqueueLockRequest(store, path, {
+ exclusive
+ });
+ yield* __unstableProcessPendingLockRequests();
+ return yield Object(external_wp_dataControls_["__unstableAwaitPromise"])(promise);
+}
+function* __unstableEnqueueLockRequest(store, path, {
+ exclusive
+}) {
+ let notifyAcquired;
+ const promise = new Promise(resolve => {
+ notifyAcquired = resolve;
+ });
+ yield {
+ type: 'ENQUEUE_LOCK_REQUEST',
+ request: {
+ store,
+ path,
+ exclusive,
+ notifyAcquired
+ }
+ };
+ return promise;
+}
+function* __unstableReleaseStoreLock(lock) {
+ yield {
+ type: 'RELEASE_LOCK',
+ lock
+ };
+ yield* __unstableProcessPendingLockRequests();
+}
+function* __unstableProcessPendingLockRequests() {
+ yield {
+ type: 'PROCESS_PENDING_LOCK_REQUESTS'
+ };
+ const lockRequests = yield external_wp_data_["controls"].select('core', '__unstableGetPendingLockRequests');
+
+ for (const request of lockRequests) {
+ const {
+ store,
+ path,
+ exclusive,
+ notifyAcquired
+ } = request;
+ const isAvailable = yield external_wp_data_["controls"].select('core', '__unstableIsLockAvailable', store, path, {
+ exclusive
+ });
+
+ if (isAvailable) {
+ const lock = {
+ store,
+ path,
+ exclusive
+ };
+ yield {
+ type: 'GRANT_LOCK_REQUEST',
+ lock,
+ request
+ };
+ notifyAcquired(lock);
+ }
+ }
+}
+
+// EXTERNAL MODULE: external ["wp","apiFetch"]
+var external_wp_apiFetch_ = __webpack_require__("ywyh");
+var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/batch/default-processor.js
+/**
+ * External dependencies
+ */
+
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Maximum number of requests to place in a single batch request. Obtained by
+ * sending a preflight OPTIONS request to /batch/v1/.
+ *
+ * @type {number?}
+ */
+
+let maxItems = null;
+/**
+ * Default batch processor. Sends its input requests to /batch/v1.
+ *
+ * @param {Array} requests List of API requests to perform at once.
+ *
+ * @return {Promise} Promise that resolves to a list of objects containing
+ * either `output` (if that request was succesful) or `error`
+ * (if not ).
+ */
+
+async function defaultProcessor(requests) {
+ if (maxItems === null) {
+ const preflightResponse = await external_wp_apiFetch_default()({
+ path: '/batch/v1',
+ method: 'OPTIONS'
+ });
+ maxItems = preflightResponse.endpoints[0].args.requests.maxItems;
+ }
+
+ const results = [];
+
+ for (const batchRequests of Object(external_lodash_["chunk"])(requests, maxItems)) {
+ const batchResponse = await external_wp_apiFetch_default()({
+ path: '/batch/v1',
+ method: 'POST',
+ data: {
+ validation: 'require-all-validate',
+ requests: batchRequests.map(request => ({
+ path: request.path,
+ body: request.data,
+ // Rename 'data' to 'body'.
+ method: request.method,
+ headers: request.headers
+ }))
+ }
+ });
+ let batchResults;
+
+ if (batchResponse.failed) {
+ batchResults = batchResponse.responses.map(response => ({
+ error: response === null || response === void 0 ? void 0 : response.body
+ }));
+ } else {
+ batchResults = batchResponse.responses.map(response => {
+ const result = {};
+
+ if (response.status >= 200 && response.status < 300) {
+ result.output = response.body;
+ } else {
+ result.error = response.body;
+ }
+
+ return result;
+ });
+ }
+
+ results.push(...batchResults);
+ }
+
+ return results;
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/batch/create-batch.js
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * Creates a batch, which can be used to combine multiple API requests into one
+ * API request using the WordPress batch processing API (/v1/batch).
+ *
+ * ```
+ * const batch = createBatch();
+ * const dunePromise = batch.add( {
+ * path: '/v1/books',
+ * method: 'POST',
+ * data: { title: 'Dune' }
+ * } );
+ * const lotrPromise = batch.add( {
+ * path: '/v1/books',
+ * method: 'POST',
+ * data: { title: 'Lord of the Rings' }
+ * } );
+ * const isSuccess = await batch.run(); // Sends one POST to /v1/batch.
+ * if ( isSuccess ) {
+ * console.log(
+ * 'Saved two books:',
+ * await dunePromise,
+ * await lotrPromise
+ * );
+ * }
+ * ```
+ *
+ * @param {Function} [processor] Processor function. Can be used to replace the
+ * default functionality which is to send an API
+ * request to /v1/batch. Is given an array of
+ * inputs and must return a promise that
+ * resolves to an array of objects containing
+ * either `output` or `error`.
+ */
+
+function createBatch(processor = defaultProcessor) {
+ let lastId = 0;
+ let queue = [];
+ const pending = new ObservableSet();
+ return {
+ /**
+ * Adds an input to the batch and returns a promise that is resolved or
+ * rejected when the input is processed by `batch.run()`.
+ *
+ * You may also pass a thunk which allows inputs to be added
+ * asychronously.
+ *
+ * ```
+ * // Both are allowed:
+ * batch.add( { path: '/v1/books', ... } );
+ * batch.add( ( add ) => add( { path: '/v1/books', ... } ) );
+ * ```
+ *
+ * If a thunk is passed, `batch.run()` will pause until either:
+ *
+ * - The thunk calls its `add` argument, or;
+ * - The thunk returns a promise and that promise resolves, or;
+ * - The thunk returns a non-promise.
+ *
+ * @param {any|Function} inputOrThunk Input to add or thunk to execute.
+
+ * @return {Promise|any} If given an input, returns a promise that
+ * is resolved or rejected when the batch is
+ * processed. If given a thunk, returns the return
+ * value of that thunk.
+ */
+ add(inputOrThunk) {
+ const id = ++lastId;
+ pending.add(id);
+
+ const add = input => new Promise((resolve, reject) => {
+ queue.push({
+ input,
+ resolve,
+ reject
+ });
+ pending.delete(id);
+ });
+
+ if (Object(external_lodash_["isFunction"])(inputOrThunk)) {
+ return Promise.resolve(inputOrThunk(add)).finally(() => {
+ pending.delete(id);
+ });
+ }
+
+ return add(inputOrThunk);
+ },
+
+ /**
+ * Runs the batch. This calls `batchProcessor` and resolves or rejects
+ * all promises returned by `add()`.
+ *
+ * @return {Promise} A promise that resolves to a boolean that is true
+ * if the processor returned no errors.
+ */
+ async run() {
+ if (pending.size) {
+ await new Promise(resolve => {
+ const unsubscribe = pending.subscribe(() => {
+ if (!pending.size) {
+ unsubscribe();
+ resolve();
+ }
+ });
+ });
+ }
+
+ let results;
+
+ try {
+ results = await processor(queue.map(({
+ input
+ }) => input));
+
+ if (results.length !== queue.length) {
+ throw new Error('run: Array returned by processor must be same size as input array.');
+ }
+ } catch (error) {
+ for (const {
+ reject
+ } of queue) {
+ reject(error);
+ }
+
+ throw error;
+ }
+
+ let isSuccess = true;
+
+ for (const [result, {
+ resolve,
+ reject
+ }] of Object(external_lodash_["zip"])(results, queue)) {
+ if (result !== null && result !== void 0 && result.error) {
+ reject(result.error);
+ isSuccess = false;
+ } else {
+ var _result$output;
+
+ resolve((_result$output = result === null || result === void 0 ? void 0 : result.output) !== null && _result$output !== void 0 ? _result$output : result);
+ }
+ }
+
+ queue = [];
+ return isSuccess;
+ }
+
+ };
+}
+
+class ObservableSet {
+ constructor(...args) {
+ this.set = new Set(...args);
+ this.subscribers = new Set();
+ }
+
+ get size() {
+ return this.set.size;
+ }
+
+ add(...args) {
+ this.set.add(...args);
+ this.subscribers.forEach(subscriber => subscriber());
+ return this;
+ }
+
+ delete(...args) {
+ const isSuccess = this.set.delete(...args);
+ this.subscribers.forEach(subscriber => subscriber());
+ return isSuccess;
+ }
+
+ subscribe(subscriber) {
+ this.subscribers.add(subscriber);
+ return () => {
+ this.subscribers.delete(subscriber);
+ };
+ }
+
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/controls.js
+/**
+ * WordPress dependencies
+ */
+
+function regularFetch(url) {
+ return {
+ type: 'REGULAR_FETCH',
+ url
+ };
+}
+function getDispatch() {
+ return {
+ type: 'GET_DISPATCH'
+ };
+}
+const controls = {
+ async REGULAR_FETCH({
+ url
+ }) {
+ const {
+ data
+ } = await window.fetch(url).then(res => res.json());
+ return data;
+ },
+
+ GET_DISPATCH: Object(external_wp_data_["createRegistryControl"])(({
+ dispatch
+ }) => () => dispatch)
+};
+/* harmony default export */ var build_module_controls = (controls);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/actions.js
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+/**
+ * Returns an action object used in signalling that authors have been received.
+ *
+ * @param {string} queryID Query ID.
+ * @param {Array|Object} users Users received.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveUserQuery(queryID, users) {
+ return {
+ type: 'RECEIVE_USER_QUERY',
+ users: Object(external_lodash_["castArray"])(users),
+ queryID
+ };
+}
+/**
+ * Returns an action used in signalling that the current user has been received.
+ *
+ * @param {Object} currentUser Current user object.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveCurrentUser(currentUser) {
+ return {
+ type: 'RECEIVE_CURRENT_USER',
+ currentUser
+ };
+}
+/**
+ * Returns an action object used in adding new entities.
+ *
+ * @param {Array} entities Entities received.
+ *
+ * @return {Object} Action object.
+ */
+
+function addEntities(entities) {
+ return {
+ type: 'ADD_ENTITIES',
+ entities
+ };
+}
+/**
+ * Returns an action object used in signalling that entity records have been received.
+ *
+ * @param {string} kind Kind of the received entity.
+ * @param {string} name Name of the received entity.
+ * @param {Array|Object} records Records received.
+ * @param {?Object} query Query Object.
+ * @param {?boolean} invalidateCache Should invalidate query caches.
+ * @param {?Object} edits Edits to reset.
+ * @return {Object} Action object.
+ */
+
+function receiveEntityRecords(kind, name, records, query, invalidateCache = false, edits) {
+ // Auto drafts should not have titles, but some plugins rely on them so we can't filter this
+ // on the server.
+ if (kind === 'postType') {
+ records = Object(external_lodash_["castArray"])(records).map(record => record.status === 'auto-draft' ? { ...record,
+ title: ''
+ } : record);
+ }
+
+ let action;
+
+ if (query) {
+ action = receiveQueriedItems(records, query, edits);
+ } else {
+ action = receiveItems(records, edits);
+ }
+
+ return { ...action,
+ kind,
+ name,
+ invalidateCache
+ };
+}
+/**
+ * Returns an action object used in signalling that the current theme has been received.
+ *
+ * @param {Object} currentTheme The current theme.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveCurrentTheme(currentTheme) {
+ return {
+ type: 'RECEIVE_CURRENT_THEME',
+ currentTheme
+ };
+}
+/**
+ * Returns an action object used in signalling that the index has been received.
+ *
+ * @param {Object} themeSupports Theme support for the current theme.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveThemeSupports(themeSupports) {
+ return {
+ type: 'RECEIVE_THEME_SUPPORTS',
+ themeSupports
+ };
+}
+/**
+ * Returns an action object used in signalling that the preview data for
+ * a given URl has been received.
+ *
+ * @param {string} url URL to preview the embed for.
+ * @param {*} preview Preview data.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveEmbedPreview(url, preview) {
+ return {
+ type: 'RECEIVE_EMBED_PREVIEW',
+ url,
+ preview
+ };
+}
+/**
+ * Action triggered to delete an entity record.
+ *
+ * @param {string} kind Kind of the deleted entity.
+ * @param {string} name Name of the deleted entity.
+ * @param {string} recordId Record ID of the deleted entity.
+ * @param {?Object} query Special query parameters for the
+ * DELETE API call.
+ * @param {Object} [options] Delete options.
+ * @param {Function} [options.__unstableFetch] Internal use only. Function to
+ * call instead of `apiFetch()`.
+ * Must return a control descriptor.
+ */
+
+function* deleteEntityRecord(kind, name, recordId, query, {
+ __unstableFetch = null
+} = {}) {
+ const entities = yield getKindEntities(kind);
+ const entity = Object(external_lodash_["find"])(entities, {
+ kind,
+ name
+ });
+ let error;
+ let deletedRecord = false;
+
+ if (!entity) {
+ return;
+ }
+
+ const lock = yield* __unstableAcquireStoreLock('core', ['entities', 'data', kind, name, recordId], {
+ exclusive: true
+ });
+
+ try {
+ yield {
+ type: 'DELETE_ENTITY_RECORD_START',
+ kind,
+ name,
+ recordId
+ };
+
+ try {
+ let path = `${entity.baseURL}/${recordId}`;
+
+ if (query) {
+ path = Object(external_wp_url_["addQueryArgs"])(path, query);
+ }
+
+ const options = {
+ path,
+ method: 'DELETE'
+ };
+
+ if (__unstableFetch) {
+ deletedRecord = yield Object(external_wp_dataControls_["__unstableAwaitPromise"])(__unstableFetch(options));
+ } else {
+ deletedRecord = yield Object(external_wp_dataControls_["apiFetch"])(options);
+ }
+
+ yield removeItems(kind, name, recordId, true);
+ } catch (_error) {
+ error = _error;
+ }
+
+ yield {
+ type: 'DELETE_ENTITY_RECORD_FINISH',
+ kind,
+ name,
+ recordId,
+ error
+ };
+ return deletedRecord;
+ } finally {
+ yield* __unstableReleaseStoreLock(lock);
+ }
+}
+/**
+ * Returns an action object that triggers an
+ * edit to an entity record.
+ *
+ * @param {string} kind Kind of the edited entity record.
+ * @param {string} name Name of the edited entity record.
+ * @param {number} recordId Record ID of the edited entity record.
+ * @param {Object} edits The edits.
+ * @param {Object} options Options for the edit.
+ * @param {boolean} options.undoIgnore Whether to ignore the edit in undo history or not.
+ *
+ * @return {Object} Action object.
+ */
+
+function* actions_editEntityRecord(kind, name, recordId, edits, options = {}) {
+ const entity = yield external_wp_data_["controls"].select('core', 'getEntity', kind, name);
+
+ if (!entity) {
+ throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
+ }
+
+ const {
+ transientEdits = {},
+ mergedEdits = {}
+ } = entity;
+ const record = yield external_wp_data_["controls"].select('core', 'getRawEntityRecord', kind, name, recordId);
+ const editedRecord = yield external_wp_data_["controls"].select('core', 'getEditedEntityRecord', kind, name, recordId);
+ const edit = {
+ kind,
+ name,
+ recordId,
+ // Clear edits when they are equal to their persisted counterparts
+ // so that the property is not considered dirty.
+ edits: Object.keys(edits).reduce((acc, key) => {
+ const recordValue = record[key];
+ const editedRecordValue = editedRecord[key];
+ const value = mergedEdits[key] ? { ...editedRecordValue,
+ ...edits[key]
+ } : edits[key];
+ acc[key] = Object(external_lodash_["isEqual"])(recordValue, value) ? undefined : value;
+ return acc;
+ }, {}),
+ transientEdits
+ };
+ return {
+ type: 'EDIT_ENTITY_RECORD',
+ ...edit,
+ meta: {
+ undo: !options.undoIgnore && { ...edit,
+ // Send the current values for things like the first undo stack entry.
+ edits: Object.keys(edits).reduce((acc, key) => {
+ acc[key] = editedRecord[key];
+ return acc;
+ }, {})
+ }
+ }
+ };
+}
+/**
+ * Action triggered to undo the last edit to
+ * an entity record, if any.
+ */
+
+function* undo() {
+ const undoEdit = yield external_wp_data_["controls"].select('core', 'getUndoEdit');
+
+ if (!undoEdit) {
+ return;
+ }
+
+ yield {
+ type: 'EDIT_ENTITY_RECORD',
+ ...undoEdit,
+ meta: {
+ isUndo: true
+ }
+ };
+}
+/**
+ * Action triggered to redo the last undoed
+ * edit to an entity record, if any.
+ */
+
+function* redo() {
+ const redoEdit = yield external_wp_data_["controls"].select('core', 'getRedoEdit');
+
+ if (!redoEdit) {
+ return;
+ }
+
+ yield {
+ type: 'EDIT_ENTITY_RECORD',
+ ...redoEdit,
+ meta: {
+ isRedo: true
+ }
+ };
+}
+/**
+ * Forces the creation of a new undo level.
+ *
+ * @return {Object} Action object.
+ */
+
+function actions_unstableCreateUndoLevel() {
+ return {
+ type: 'CREATE_UNDO_LEVEL'
+ };
}
-// 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.");
+/**
+ * Action triggered to save an entity record.
+ *
+ * @param {string} kind Kind of the received entity.
+ * @param {string} name Name of the received entity.
+ * @param {Object} record Record to be saved.
+ * @param {Object} options Saving options.
+ * @param {boolean} [options.isAutosave=false] Whether this is an autosave.
+ * @param {Function} [options.__unstableFetch] Internal use only. Function to
+ * call instead of `apiFetch()`.
+ * Must return a control
+ * descriptor.
+ */
+
+function* saveEntityRecord(kind, name, record, {
+ isAutosave = false,
+ __unstableFetch = null
+} = {}) {
+ const entities = yield getKindEntities(kind);
+ const entity = Object(external_lodash_["find"])(entities, {
+ kind,
+ name
+ });
+
+ if (!entity) {
+ return;
+ }
+
+ const entityIdKey = entity.key || DEFAULT_ENTITY_KEY;
+ const recordId = record[entityIdKey];
+ const lock = yield* __unstableAcquireStoreLock('core', ['entities', 'data', kind, name, recordId || Object(v4["a" /* default */])()], {
+ exclusive: true
+ });
+
+ try {
+ // Evaluate optimized edits.
+ // (Function edits that should be evaluated on save to avoid expensive computations on every edit.)
+ for (const [key, value] of Object.entries(record)) {
+ if (typeof value === 'function') {
+ const evaluatedValue = value(yield external_wp_data_["controls"].select('core', 'getEditedEntityRecord', kind, name, recordId));
+ yield actions_editEntityRecord(kind, name, recordId, {
+ [key]: evaluatedValue
+ }, {
+ undoIgnore: true
+ });
+ record[key] = evaluatedValue;
+ }
+ }
+
+ yield {
+ type: 'SAVE_ENTITY_RECORD_START',
+ kind,
+ name,
+ recordId,
+ isAutosave
+ };
+ let updatedRecord;
+ let error;
+
+ try {
+ const path = `${entity.baseURL}${recordId ? '/' + recordId : ''}`;
+ const persistedRecord = yield external_wp_data_["controls"].select('core', 'getRawEntityRecord', kind, name, recordId);
+
+ if (isAutosave) {
+ // Most of this autosave logic is very specific to posts.
+ // This is fine for now as it is the only supported autosave,
+ // but ideally this should all be handled in the back end,
+ // so the client just sends and receives objects.
+ const currentUser = yield external_wp_data_["controls"].select('core', 'getCurrentUser');
+ const currentUserId = currentUser ? currentUser.id : undefined;
+ const autosavePost = yield external_wp_data_["controls"].select('core', 'getAutosave', persistedRecord.type, persistedRecord.id, currentUserId); // Autosaves need all expected fields to be present.
+ // So we fallback to the previous autosave and then
+ // to the actual persisted entity if the edits don't
+ // have a value.
+
+ let data = { ...persistedRecord,
+ ...autosavePost,
+ ...record
+ };
+ data = Object.keys(data).reduce((acc, key) => {
+ if (['title', 'excerpt', 'content'].includes(key)) {
+ // Edits should be the "raw" attribute values.
+ acc[key] = Object(external_lodash_["get"])(data[key], 'raw', data[key]);
+ }
+
+ return acc;
+ }, {
+ status: data.status === 'auto-draft' ? 'draft' : data.status
+ });
+ const options = {
+ path: `${path}/autosaves`,
+ method: 'POST',
+ data
+ };
+
+ if (__unstableFetch) {
+ updatedRecord = yield Object(external_wp_dataControls_["__unstableAwaitPromise"])(__unstableFetch(options));
+ } else {
+ updatedRecord = yield Object(external_wp_dataControls_["apiFetch"])(options);
+ } // An autosave may be processed by the server as a regular save
+ // when its update is requested by the author and the post had
+ // draft or auto-draft status.
+
+
+ if (persistedRecord.id === updatedRecord.id) {
+ let newRecord = { ...persistedRecord,
+ ...data,
+ ...updatedRecord
+ };
+ newRecord = Object.keys(newRecord).reduce((acc, key) => {
+ // These properties are persisted in autosaves.
+ if (['title', 'excerpt', 'content'].includes(key)) {
+ // Edits should be the "raw" attribute values.
+ acc[key] = Object(external_lodash_["get"])(newRecord[key], 'raw', newRecord[key]);
+ } else if (key === 'status') {
+ // Status is only persisted in autosaves when going from
+ // "auto-draft" to "draft".
+ acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status;
+ } else {
+ // These properties are not persisted in autosaves.
+ acc[key] = Object(external_lodash_["get"])(persistedRecord[key], 'raw', persistedRecord[key]);
+ }
+
+ return acc;
+ }, {});
+ yield receiveEntityRecords(kind, name, newRecord, undefined, true);
+ } else {
+ yield receiveAutosaves(persistedRecord.id, updatedRecord);
+ }
+ } else {
+ let edits = record;
+
+ if (entity.__unstablePrePersist) {
+ edits = { ...edits,
+ ...entity.__unstablePrePersist(persistedRecord, edits)
+ };
+ }
+
+ const options = {
+ path,
+ method: recordId ? 'PUT' : 'POST',
+ data: edits
+ };
+
+ if (__unstableFetch) {
+ updatedRecord = yield Object(external_wp_dataControls_["__unstableAwaitPromise"])(__unstableFetch(options));
+ } else {
+ updatedRecord = yield Object(external_wp_dataControls_["apiFetch"])(options);
+ }
+
+ yield receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
+ }
+ } catch (_error) {
+ error = _error;
+ }
+
+ yield {
+ type: 'SAVE_ENTITY_RECORD_FINISH',
+ kind,
+ name,
+ recordId,
+ error,
+ isAutosave
+ };
+ return updatedRecord;
+ } finally {
+ yield* __unstableReleaseStoreLock(lock);
+ }
+}
+/**
+ * Runs multiple core-data actions at the same time using one API request.
+ *
+ * Example:
+ *
+ * ```
+ * const [ savedRecord, updatedRecord, deletedRecord ] =
+ * await dispatch( 'core' ).__experimentalBatch( [
+ * ( { saveEntityRecord } ) => saveEntityRecord( 'root', 'widget', widget ),
+ * ( { saveEditedEntityRecord } ) => saveEntityRecord( 'root', 'widget', 123 ),
+ * ( { deleteEntityRecord } ) => deleteEntityRecord( 'root', 'widget', 123, null ),
+ * ] );
+ * ```
+ *
+ * @param {Array} requests Array of functions which are invoked simultaneously.
+ * Each function is passed an object containing
+ * `saveEntityRecord`, `saveEditedEntityRecord`, and
+ * `deleteEntityRecord`.
+ *
+ * @return {Promise} A promise that resolves to an array containing the return
+ * values of each function given in `requests`.
+ */
+
+function* __experimentalBatch(requests) {
+ const batch = createBatch();
+ const dispatch = yield getDispatch();
+ const api = {
+ saveEntityRecord(kind, name, record, options) {
+ return batch.add(add => dispatch('core').saveEntityRecord(kind, name, record, { ...options,
+ __unstableFetch: add
+ }));
+ },
+
+ saveEditedEntityRecord(kind, name, recordId, options) {
+ return batch.add(add => dispatch('core').saveEditedEntityRecord(kind, name, recordId, { ...options,
+ __unstableFetch: add
+ }));
+ },
+
+ deleteEntityRecord(kind, name, recordId, query, options) {
+ return batch.add(add => dispatch('core').deleteEntityRecord(kind, name, recordId, query, { ...options,
+ __unstableFetch: add
+ }));
+ }
+
+ };
+ const resultPromises = requests.map(request => request(api));
+ const [, ...results] = yield Object(external_wp_dataControls_["__unstableAwaitPromise"])(Promise.all([batch.run(), ...resultPromises]));
+ return results;
+}
+/**
+ * Action triggered to save an entity record's edits.
+ *
+ * @param {string} kind Kind of the entity.
+ * @param {string} name Name of the entity.
+ * @param {Object} recordId ID of the record.
+ * @param {Object} options Saving options.
+ */
+
+function* saveEditedEntityRecord(kind, name, recordId, options) {
+ if (!(yield external_wp_data_["controls"].select('core', 'hasEditsForEntityRecord', kind, name, recordId))) {
+ return;
+ }
+
+ const edits = yield external_wp_data_["controls"].select('core', 'getEntityRecordNonTransientEdits', kind, name, recordId);
+ const record = {
+ id: recordId,
+ ...edits
+ };
+ return yield* saveEntityRecord(kind, name, record, options);
+}
+/**
+ * Action triggered to save only specified properties for the entity.
+ *
+ * @param {string} kind Kind of the entity.
+ * @param {string} name Name of the entity.
+ * @param {Object} recordId ID of the record.
+ * @param {Array} itemsToSave List of entity properties to save.
+ * @param {Object} options Saving options.
+ */
+
+function* __experimentalSaveSpecifiedEntityEdits(kind, name, recordId, itemsToSave, options) {
+ if (!(yield external_wp_data_["controls"].select('core', 'hasEditsForEntityRecord', kind, name, recordId))) {
+ return;
+ }
+
+ const edits = yield external_wp_data_["controls"].select('core', 'getEntityRecordNonTransientEdits', kind, name, recordId);
+ const editsToSave = {};
+
+ for (const edit in edits) {
+ if (itemsToSave.some(item => item === edit)) {
+ editsToSave[edit] = edits[edit];
+ }
+ }
+
+ return yield* saveEntityRecord(kind, name, editsToSave, options);
+}
+/**
+ * Returns an action object used in signalling that Upload permissions have been received.
+ *
+ * @param {boolean} hasUploadPermissions Does the user have permission to upload files?
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveUploadPermissions(hasUploadPermissions) {
+ return {
+ type: 'RECEIVE_USER_PERMISSION',
+ key: 'create/media',
+ isAllowed: hasUploadPermissions
+ };
+}
+/**
+ * Returns an action object used in signalling that the current user has
+ * permission to perform an action on a REST resource.
+ *
+ * @param {string} key A key that represents the action and REST resource.
+ * @param {boolean} isAllowed Whether or not the user can perform the action.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveUserPermission(key, isAllowed) {
+ return {
+ type: 'RECEIVE_USER_PERMISSION',
+ key,
+ isAllowed
+ };
+}
+/**
+ * Returns an action object used in signalling that the autosaves for a
+ * post have been received.
+ *
+ * @param {number} postId The id of the post that is parent to the autosave.
+ * @param {Array|Object} autosaves An array of autosaves or singular autosave object.
+ *
+ * @return {Object} Action object.
+ */
+
+function receiveAutosaves(postId, autosaves) {
+ return {
+ type: 'RECEIVE_AUTOSAVES',
+ postId,
+ autosaves: Object(external_lodash_["castArray"])(autosaves)
+ };
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js
+/**
+ * External dependencies
+ */
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+const DEFAULT_ENTITY_KEY = 'id';
+const defaultEntities = [{
+ label: Object(external_wp_i18n_["__"])('Base'),
+ name: '__unstableBase',
+ kind: 'root',
+ baseURL: ''
+}, {
+ label: Object(external_wp_i18n_["__"])('Site'),
+ name: 'site',
+ kind: 'root',
+ baseURL: '/wp/v2/settings',
+ getTitle: record => {
+ return Object(external_lodash_["get"])(record, ['title'], Object(external_wp_i18n_["__"])('Site Title'));
+ }
+}, {
+ label: Object(external_wp_i18n_["__"])('Post Type'),
+ name: 'postType',
+ kind: 'root',
+ key: 'slug',
+ baseURL: '/wp/v2/types',
+ baseURLParams: {
+ context: 'edit'
+ }
+}, {
+ name: 'media',
+ kind: 'root',
+ baseURL: '/wp/v2/media',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'mediaItems',
+ label: Object(external_wp_i18n_["__"])('Media')
+}, {
+ name: 'taxonomy',
+ kind: 'root',
+ key: 'slug',
+ baseURL: '/wp/v2/taxonomies',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'taxonomies',
+ label: Object(external_wp_i18n_["__"])('Taxonomy')
+}, {
+ name: 'sidebar',
+ kind: 'root',
+ baseURL: '/wp/v2/sidebars',
+ plural: 'sidebars',
+ transientEdits: {
+ blocks: true
+ },
+ label: Object(external_wp_i18n_["__"])('Widget areas')
+}, {
+ name: 'widget',
+ kind: 'root',
+ baseURL: '/wp/v2/widgets',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'widgets',
+ transientEdits: {
+ blocks: true
+ },
+ label: Object(external_wp_i18n_["__"])('Widgets')
+}, {
+ name: 'widgetType',
+ kind: 'root',
+ baseURL: '/wp/v2/widget-types',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'widgetTypes',
+ label: Object(external_wp_i18n_["__"])('Widget types')
+}, {
+ label: Object(external_wp_i18n_["__"])('User'),
+ name: 'user',
+ kind: 'root',
+ baseURL: '/wp/v2/users',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'users'
+}, {
+ name: 'comment',
+ kind: 'root',
+ baseURL: '/wp/v2/comments',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'comments',
+ label: Object(external_wp_i18n_["__"])('Comment')
+}, {
+ name: 'menu',
+ kind: 'root',
+ baseURL: '/__experimental/menus',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'menus',
+ label: Object(external_wp_i18n_["__"])('Menu')
+}, {
+ name: 'menuItem',
+ kind: 'root',
+ baseURL: '/__experimental/menu-items',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'menuItems',
+ label: Object(external_wp_i18n_["__"])('Menu Item')
+}, {
+ name: 'menuLocation',
+ kind: 'root',
+ baseURL: '/__experimental/menu-locations',
+ baseURLParams: {
+ context: 'edit'
+ },
+ plural: 'menuLocations',
+ label: Object(external_wp_i18n_["__"])('Menu Location'),
+ key: 'name'
+}];
+const kinds = [{
+ name: 'postType',
+ loadEntities: loadPostTypeEntities
+}, {
+ name: 'taxonomy',
+ loadEntities: loadTaxonomyEntities
+}];
+/**
+ * Returns a function to be used to retrieve extra edits to apply before persisting a post type.
+ *
+ * @param {Object} persistedRecord Already persisted Post
+ * @param {Object} edits Edits.
+ * @return {Object} Updated edits.
+ */
+
+const prePersistPostType = (persistedRecord, edits) => {
+ const newEdits = {};
+
+ if ((persistedRecord === null || persistedRecord === void 0 ? void 0 : persistedRecord.status) === 'auto-draft') {
+ // Saving an auto-draft should create a draft by default.
+ if (!edits.status && !newEdits.status) {
+ newEdits.status = 'draft';
+ } // Fix the auto-draft default title.
+
+
+ if ((!edits.title || edits.title === 'Auto Draft') && !newEdits.title && (!(persistedRecord !== null && persistedRecord !== void 0 && persistedRecord.title) || (persistedRecord === null || persistedRecord === void 0 ? void 0 : persistedRecord.title) === 'Auto Draft')) {
+ newEdits.title = '';
+ }
+ }
+
+ return newEdits;
+};
+/**
+ * Returns the list of post type entities.
+ *
+ * @return {Promise} Entities promise
+ */
+
+function* loadPostTypeEntities() {
+ const postTypes = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: '/wp/v2/types?context=edit'
+ });
+ return Object(external_lodash_["map"])(postTypes, (postType, name) => {
+ const isTemplate = ['wp_template', 'wp_template_part'].includes(name);
+ return {
+ kind: 'postType',
+ baseURL: '/wp/v2/' + postType.rest_base,
+ baseURLParams: {
+ context: 'edit'
+ },
+ name,
+ label: postType.labels.singular_name,
+ transientEdits: {
+ blocks: true,
+ selection: true
+ },
+ mergedEdits: {
+ meta: true
+ },
+ getTitle: record => {
+ var _record$title;
+
+ return (record === null || record === void 0 ? void 0 : (_record$title = record.title) === null || _record$title === void 0 ? void 0 : _record$title.rendered) || (record === null || record === void 0 ? void 0 : record.title) || (isTemplate ? Object(external_lodash_["startCase"])(record.slug) : String(record.id));
+ },
+ __unstablePrePersist: isTemplate ? undefined : prePersistPostType,
+ __unstable_rest_base: postType.rest_base
+ };
+ });
+}
+/**
+ * Returns the list of the taxonomies entities.
+ *
+ * @return {Promise} Entities promise
+ */
+
+
+function* loadTaxonomyEntities() {
+ const taxonomies = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: '/wp/v2/taxonomies?context=edit'
+ });
+ return Object(external_lodash_["map"])(taxonomies, (taxonomy, name) => {
+ return {
+ kind: 'taxonomy',
+ baseURL: '/wp/v2/' + taxonomy.rest_base,
+ baseURLParams: {
+ context: 'edit'
+ },
+ name,
+ label: taxonomy.labels.singular_name
+ };
+ });
+}
+/**
+ * Returns the entity's getter method name given its kind and name.
+ *
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {string} prefix Function prefix.
+ * @param {boolean} usePlural Whether to use the plural form or not.
+ *
+ * @return {string} Method name
+ */
+
+
+const getMethodName = (kind, name, prefix = 'get', usePlural = false) => {
+ const entity = Object(external_lodash_["find"])(defaultEntities, {
+ kind,
+ name
+ });
+ const kindPrefix = kind === 'root' ? '' : Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(kind));
+ const nameSuffix = Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(name)) + (usePlural ? 's' : '');
+ const suffix = usePlural && entity.plural ? Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(entity.plural)) : nameSuffix;
+ return `${prefix}${kindPrefix}${suffix}`;
+};
+/**
+ * Loads the kind entities into the store.
+ *
+ * @param {string} kind Kind
+ *
+ * @return {Array} Entities
+ */
+
+function* getKindEntities(kind) {
+ let entities = yield external_wp_data_["controls"].select('core', 'getEntitiesByKind', kind);
+
+ if (entities && entities.length !== 0) {
+ return entities;
+ }
+
+ const kindConfig = Object(external_lodash_["find"])(kinds, {
+ name: kind
+ });
+
+ if (!kindConfig) {
+ return [];
+ }
+
+ entities = yield kindConfig.loadEntities();
+ yield addEntities(entities);
+ return entities;
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/get-normalized-comma-separable.js
+/**
+ * Given a value which can be specified as one or the other of a comma-separated
+ * string or an array, returns a value normalized to an array of strings, or
+ * null if the value cannot be interpreted as either.
+ *
+ * @param {string|string[]|*} value
+ *
+ * @return {?(string[])} Normalized field value.
+ */
+function getNormalizedCommaSeparable(value) {
+ if (typeof value === 'string') {
+ return value.split(',');
+ } else if (Array.isArray(value)) {
+ return value;
+ }
+
+ return null;
}
-// 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();
+
+/* harmony default export */ var get_normalized_comma_separable = (getNormalizedCommaSeparable);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js
+/**
+ * External dependencies
+ */
+
+/**
+ * Given a function, returns an enhanced function which caches the result and
+ * tracks in WeakMap. The result is only cached if the original function is
+ * passed a valid object-like argument (requirement for WeakMap key).
+ *
+ * @param {Function} fn Original function.
+ *
+ * @return {Function} Enhanced caching function.
+ */
+
+function withWeakMapCache(fn) {
+ const cache = new WeakMap();
+ return key => {
+ let value;
+
+ if (cache.has(key)) {
+ value = cache.get(key);
+ } else {
+ value = fn(key); // Can reach here if key is not valid for WeakMap, since `has`
+ // will return false for invalid key. Since `set` will throw,
+ // ensure that key is valid before setting into cache.
+
+ if (Object(external_lodash_["isObjectLike"])(key)) {
+ cache.set(key, value);
+ }
+ }
+
+ return value;
+ };
+}
+
+/* harmony default export */ var with_weak_map_cache = (withWeakMapCache);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js
+/**
+ * WordPress dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * An object of properties describing a specific query.
+ *
+ * @typedef {Object} WPQueriedDataQueryParts
+ *
+ * @property {number} page The query page (1-based index, default 1).
+ * @property {number} perPage Items per page for query (default 10).
+ * @property {string} stableKey An encoded stable string of all non-
+ * pagination, non-fields query parameters.
+ * @property {?(string[])} fields Target subset of fields to derive from
+ * item objects.
+ * @property {?(number[])} include Specific item IDs to include.
+ */
+
+/**
+ * Given a query object, returns an object of parts, including pagination
+ * details (`page` and `perPage`, or default values). All other properties are
+ * encoded into a stable (idempotent) `stableKey` value.
+ *
+ * @param {Object} query Optional query object.
+ *
+ * @return {WPQueriedDataQueryParts} Query parts.
+ */
+
+function getQueryParts(query) {
+ /**
+ * @type {WPQueriedDataQueryParts}
+ */
+ const parts = {
+ stableKey: '',
+ page: 1,
+ perPage: 10,
+ fields: null,
+ include: null,
+ context: 'default'
+ }; // Ensure stable key by sorting keys. Also more efficient for iterating.
+
+ const keys = Object.keys(query).sort();
+
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ let value = query[key];
+
+ switch (key) {
+ case 'page':
+ parts[key] = Number(value);
+ break;
+
+ case 'per_page':
+ parts.perPage = Number(value);
+ break;
+
+ case 'include':
+ parts.include = get_normalized_comma_separable(value).map(Number);
+ break;
+
+ case 'context':
+ parts.context = value;
+ break;
+
+ default:
+ // While in theory, we could exclude "_fields" from the stableKey
+ // because two request with different fields have the same results
+ // We're not able to ensure that because the server can decide to omit
+ // fields from the response even if we explicitely asked for it.
+ // Example: Asking for titles in posts without title support.
+ if (key === '_fields') {
+ parts.fields = get_normalized_comma_separable(value); // Make sure to normalize value for `stableKey`
+
+ value = parts.fields.join();
+ } // While it could be any deterministic string, for simplicity's
+ // sake mimic querystring encoding for stable key.
+ //
+ // TODO: For consistency with PHP implementation, addQueryArgs
+ // should accept a key value pair, which may optimize its
+ // implementation for our use here, vs. iterating an object
+ // with only a single key.
+
+
+ parts.stableKey += (parts.stableKey ? '&' : '') + Object(external_wp_url_["addQueryArgs"])('', {
+ [key]: value
+ }).slice(1);
+ }
+ }
+
+ return parts;
+}
+/* harmony default export */ var get_query_parts = (with_weak_map_cache(getQueryParts));
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js
+/**
+ * External dependencies
+ */
+
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+function getContextFromAction(action) {
+ const {
+ query
+ } = action;
+
+ if (!query) {
+ return 'default';
+ }
+
+ const queryParts = get_query_parts(query);
+ return queryParts.context;
+}
+/**
+ * Returns a merged array of item IDs, given details of the received paginated
+ * items. The array is sparse-like with `undefined` entries where holes exist.
+ *
+ * @param {?Array<number>} itemIds Original item IDs (default empty array).
+ * @param {number[]} nextItemIds Item IDs to merge.
+ * @param {number} page Page of items merged.
+ * @param {number} perPage Number of items per page.
+ *
+ * @return {number[]} Merged array of item IDs.
+ */
+
+
+function getMergedItemIds(itemIds, nextItemIds, page, perPage) {
+ const receivedAllIds = page === 1 && perPage === -1;
+
+ if (receivedAllIds) {
+ return nextItemIds;
+ }
+
+ const nextItemIdsStartIndex = (page - 1) * perPage; // If later page has already been received, default to the larger known
+ // size of the existing array, else calculate as extending the existing.
+
+ const size = Math.max(itemIds.length, nextItemIdsStartIndex + nextItemIds.length); // Preallocate array since size is known.
+
+ const mergedItemIds = new Array(size);
+
+ for (let i = 0; i < size; i++) {
+ // Preserve existing item ID except for subset of range of next items.
+ const isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIds.length;
+ mergedItemIds[i] = isInNextItemsRange ? nextItemIds[i - nextItemIdsStartIndex] : itemIds[i];
+ }
+
+ return mergedItemIds;
+}
+/**
+ * Reducer tracking items state, keyed by ID. Items are assumed to be normal,
+ * where identifiers are common across all queries.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Next state.
+ */
+
+function reducer_items(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_ITEMS':
+ {
+ const context = getContextFromAction(action);
+ const key = action.key || DEFAULT_ENTITY_KEY;
+ return { ...state,
+ [context]: { ...state[context],
+ ...action.items.reduce((accumulator, value) => {
+ var _state$context;
+
+ const itemId = value[key];
+ accumulator[itemId] = conservativeMapItem(state === null || state === void 0 ? void 0 : (_state$context = state[context]) === null || _state$context === void 0 ? void 0 : _state$context[itemId], value);
+ return accumulator;
+ }, {})
+ }
+ };
+ }
+
+ case 'REMOVE_ITEMS':
+ return Object(external_lodash_["mapValues"])(state, contextState => Object(external_lodash_["omit"])(contextState, action.itemIds));
+ }
+
+ return state;
+}
+/**
+ * Reducer tracking item completeness, keyed by ID. A complete item is one for
+ * which all fields are known. This is used in supporting `_fields` queries,
+ * where not all properties associated with an entity are necessarily returned.
+ * In such cases, completeness is used as an indication of whether it would be
+ * safe to use queried data for a non-`_fields`-limited request.
+ *
+ * @param {Object<string,boolean>} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object<string,boolean>} Next state.
+ */
+
+function itemIsComplete(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_ITEMS':
+ {
+ const context = getContextFromAction(action);
+ const {
+ query,
+ key = DEFAULT_ENTITY_KEY
+ } = action; // An item is considered complete if it is received without an associated
+ // fields query. Ideally, this would be implemented in such a way where the
+ // complete aggregate of all fields would satisfy completeness. Since the
+ // fields are not consistent across all entity types, this would require
+ // introspection on the REST schema for each entity to know which fields
+ // compose a complete item for that entity.
+
+ const queryParts = query ? get_query_parts(query) : {};
+ const isCompleteQuery = !query || !Array.isArray(queryParts.fields);
+ return { ...state,
+ [context]: { ...state[context],
+ ...action.items.reduce((result, item) => {
+ var _state$context2;
+
+ const itemId = item[key]; // Defer to completeness if already assigned. Technically the
+ // data may be outdated if receiving items for a field subset.
+
+ result[itemId] = (state === null || state === void 0 ? void 0 : (_state$context2 = state[context]) === null || _state$context2 === void 0 ? void 0 : _state$context2[itemId]) || isCompleteQuery;
+ return result;
+ }, {})
+ }
+ };
+ }
+
+ case 'REMOVE_ITEMS':
+ return Object(external_lodash_["mapValues"])(state, contextState => Object(external_lodash_["omit"])(contextState, action.itemIds));
+ }
+
+ return state;
+}
+/**
+ * Reducer tracking queries state, keyed by stable query key. Each reducer
+ * query object includes `itemIds` and `requestingPageByPerPage`.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Next state.
+ */
+
+const receiveQueries = Object(external_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
+// an unhandled action.
+if_matching_action(action => 'query' in action), // Inject query parts into action for use both in `onSubKey` and reducer.
+replace_action(action => {
+ // `ifMatchingAction` still passes on initialization, where state is
+ // undefined and a query is not assigned. Avoid attempting to parse
+ // parts. `onSubKey` will omit by lack of `stableKey`.
+ if (action.query) {
+ return { ...action,
+ ...get_query_parts(action.query)
+ };
+ }
+
+ return action;
+}), on_sub_key('context'), // Queries shape is shared, but keyed by query `stableKey` part. Original
+// reducer tracks only a single query object.
+on_sub_key('stableKey')])((state = null, action) => {
+ const {
+ type,
+ page,
+ perPage,
+ key = DEFAULT_ENTITY_KEY
+ } = action;
+
+ if (type !== 'RECEIVE_ITEMS') {
+ return state;
+ }
+
+ return getMergedItemIds(state || [], Object(external_lodash_["map"])(action.items, key), page, perPage);
+});
+/**
+ * Reducer tracking queries state.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Next state.
+ */
+
+const reducer_queries = (state = {}, action) => {
+ switch (action.type) {
+ case 'RECEIVE_ITEMS':
+ return receiveQueries(state, action);
+
+ case 'REMOVE_ITEMS':
+ const removedItems = action.itemIds.reduce((result, itemId) => {
+ result[itemId] = true;
+ return result;
+ }, {});
+ return Object(external_lodash_["mapValues"])(state, contextQueries => {
+ return Object(external_lodash_["mapValues"])(contextQueries, queryItems => {
+ return Object(external_lodash_["filter"])(queryItems, queryId => {
+ return !removedItems[queryId];
+ });
+ });
+ });
+
+ default:
+ return state;
+ }
+};
+
+/* harmony default export */ var reducer = (Object(external_wp_data_["combineReducers"])({
+ items: reducer_items,
+ itemIsComplete,
+ queries: reducer_queries
+}));
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/locks/utils.js
+function deepCopyLocksTreePath(tree, path) {
+ const newTree = { ...tree
+ };
+ let currentNode = newTree;
+
+ for (const branchName of path) {
+ currentNode.children = { ...currentNode.children,
+ [branchName]: {
+ locks: [],
+ children: {},
+ ...currentNode.children[branchName]
+ }
+ };
+ currentNode = currentNode.children[branchName];
+ }
+
+ return newTree;
+}
+function getNode(tree, path) {
+ let currentNode = tree;
+
+ for (const branchName of path) {
+ const nextNode = currentNode.children[branchName];
+
+ if (!nextNode) {
+ return null;
+ }
+
+ currentNode = nextNode;
+ }
+
+ return currentNode;
+}
+function* iteratePath(tree, path) {
+ let currentNode = tree;
+ yield currentNode;
+
+ for (const branchName of path) {
+ const nextNode = currentNode.children[branchName];
+
+ if (!nextNode) {
+ break;
+ }
+
+ yield nextNode;
+ currentNode = nextNode;
+ }
+}
+function* iterateDescendants(node) {
+ const stack = Object.values(node.children);
+
+ while (stack.length) {
+ const childNode = stack.pop();
+ yield childNode;
+ stack.push(...Object.values(childNode.children));
+ }
+}
+function hasConflictingLock({
+ exclusive
+}, locks) {
+ if (exclusive && locks.length) {
+ return true;
+ }
+
+ if (!exclusive && locks.filter(lock => lock.exclusive).length) {
+ return true;
+ }
+
+ return false;
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/locks/reducer.js
+/**
+ * Internal dependencies
+ */
+
+const DEFAULT_STATE = {
+ requests: [],
+ tree: {
+ locks: [],
+ children: {}
+ }
+};
+/**
+ * Reducer returning locks.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function reducer_locks(state = DEFAULT_STATE, action) {
+ switch (action.type) {
+ case 'ENQUEUE_LOCK_REQUEST':
+ {
+ const {
+ request
+ } = action;
+ return { ...state,
+ requests: [request, ...state.requests]
+ };
+ }
+
+ case 'GRANT_LOCK_REQUEST':
+ {
+ const {
+ lock,
+ request
+ } = action;
+ const {
+ store,
+ path
+ } = request;
+ const storePath = [store, ...path];
+ const newTree = deepCopyLocksTreePath(state.tree, storePath);
+ const node = getNode(newTree, storePath);
+ node.locks = [...node.locks, lock];
+ return { ...state,
+ requests: state.requests.filter(r => r !== request),
+ tree: newTree
+ };
+ }
+
+ case 'RELEASE_LOCK':
+ {
+ const {
+ lock
+ } = action;
+ const storePath = [lock.store, ...lock.path];
+ const newTree = deepCopyLocksTreePath(state.tree, storePath);
+ const node = getNode(newTree, storePath);
+ node.locks = node.locks.filter(l => l !== lock);
+ return { ...state,
+ tree: newTree
+ };
+ }
+ }
+
+ return state;
+}
+/* harmony default export */ var locks_reducer = (reducer_locks);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/reducer.js
+/**
+ * External dependencies
+ */
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Reducer managing terms state. Keyed by taxonomy slug, the value is either
+ * undefined (if no request has been made for given taxonomy), null (if a
+ * request is in-flight for given taxonomy), or the array of terms for the
+ * taxonomy.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function terms(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_TERMS':
+ return { ...state,
+ [action.taxonomy]: action.terms
+ };
+ }
+
+ return state;
+}
+/**
+ * Reducer managing authors state. Keyed by id.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function reducer_users(state = {
+ byId: {},
+ queries: {}
+}, action) {
+ switch (action.type) {
+ case 'RECEIVE_USER_QUERY':
+ return {
+ byId: { ...state.byId,
+ ...Object(external_lodash_["keyBy"])(action.users, 'id')
+ },
+ queries: { ...state.queries,
+ [action.queryID]: Object(external_lodash_["map"])(action.users, user => user.id)
+ }
+ };
+ }
+
+ return state;
+}
+/**
+ * Reducer managing current user state.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function reducer_currentUser(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_CURRENT_USER':
+ return action.currentUser;
+ }
+
+ return state;
+}
+/**
+ * Reducer managing taxonomies.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function reducer_taxonomies(state = [], action) {
+ switch (action.type) {
+ case 'RECEIVE_TAXONOMIES':
+ return action.taxonomies;
+ }
+
+ return state;
+}
+/**
+ * Reducer managing the current theme.
+ *
+ * @param {string} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {string} Updated state.
+ */
+
+function currentTheme(state = undefined, action) {
+ switch (action.type) {
+ case 'RECEIVE_CURRENT_THEME':
+ return action.currentTheme.stylesheet;
+ }
+
+ return state;
}
-
-/***/ }),
-
-/***/ 2:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["lodash"]; }());
-
-/***/ }),
-
-/***/ 24:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["regeneratorRuntime"]; }());
-
-/***/ }),
-
-/***/ 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];
+/**
+ * Reducer managing installed themes.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function themes(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_CURRENT_THEME':
+ return { ...state,
+ [action.currentTheme.stylesheet]: action.currentTheme
+ };
+ }
+
+ return state;
+}
+/**
+ * Reducer managing theme supports data.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function themeSupports(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_THEME_SUPPORTS':
+ return { ...state,
+ ...action.themeSupports
+ };
+ }
+
+ return state;
+}
+/**
+ * Higher Order Reducer for a given entity config. It supports:
+ *
+ * - Fetching
+ * - Editing
+ * - Saving
+ *
+ * @param {Object} entityConfig Entity config.
+ *
+ * @return {Function} Reducer.
+ */
+
+function reducer_entity(entityConfig) {
+ return Object(external_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
+ // an unhandled action.
+ if_matching_action(action => action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind), // Inject the entity config into the action.
+ replace_action(action => {
+ return { ...action,
+ key: entityConfig.key || DEFAULT_ENTITY_KEY
+ };
+ })])(Object(external_wp_data_["combineReducers"])({
+ queriedData: reducer,
+ edits: (state = {}, action) => {
+ var _action$query$context, _action$query;
+
+ switch (action.type) {
+ case 'RECEIVE_ITEMS':
+ const context = (_action$query$context = action === null || action === void 0 ? void 0 : (_action$query = action.query) === null || _action$query === void 0 ? void 0 : _action$query.context) !== null && _action$query$context !== void 0 ? _action$query$context : 'default';
+
+ if (context !== 'default') {
+ return state;
+ }
+
+ const nextState = { ...state
+ };
+
+ for (const record of action.items) {
+ const recordId = record[action.key];
+ const edits = nextState[recordId];
+
+ if (!edits) {
+ continue;
+ }
+
+ const nextEdits = Object.keys(edits).reduce((acc, key) => {
+ // If the edited value is still different to the persisted value,
+ // keep the edited value in edits.
+ if ( // Edits are the "raw" attribute values, but records may have
+ // objects with more properties, so we use `get` here for the
+ // comparison.
+ !Object(external_lodash_["isEqual"])(edits[key], Object(external_lodash_["get"])(record[key], 'raw', record[key])) && ( // Sometimes the server alters the sent value which means
+ // we need to also remove the edits before the api request.
+ !action.persistedEdits || !Object(external_lodash_["isEqual"])(edits[key], action.persistedEdits[key]))) {
+ acc[key] = edits[key];
+ }
+
+ return acc;
+ }, {});
+
+ if (Object.keys(nextEdits).length) {
+ nextState[recordId] = nextEdits;
+ } else {
+ delete nextState[recordId];
+ }
+ }
+
+ return nextState;
+
+ case 'EDIT_ENTITY_RECORD':
+ const nextEdits = { ...state[action.recordId],
+ ...action.edits
+ };
+ Object.keys(nextEdits).forEach(key => {
+ // Delete cleared edits so that the properties
+ // are not considered dirty.
+ if (nextEdits[key] === undefined) {
+ delete nextEdits[key];
+ }
+ });
+ return { ...state,
+ [action.recordId]: nextEdits
+ };
+ }
+
+ return state;
+ },
+ saving: (state = {}, action) => {
+ switch (action.type) {
+ case 'SAVE_ENTITY_RECORD_START':
+ case 'SAVE_ENTITY_RECORD_FINISH':
+ return { ...state,
+ [action.recordId]: {
+ pending: action.type === 'SAVE_ENTITY_RECORD_START',
+ error: action.error,
+ isAutosave: action.isAutosave
+ }
+ };
+ }
+
+ return state;
+ },
+ deleting: (state = {}, action) => {
+ switch (action.type) {
+ case 'DELETE_ENTITY_RECORD_START':
+ case 'DELETE_ENTITY_RECORD_FINISH':
+ return { ...state,
+ [action.recordId]: {
+ pending: action.type === 'DELETE_ENTITY_RECORD_START',
+ error: action.error
+ }
+ };
+ }
+
+ return state;
+ }
+ }));
+}
+/**
+ * Reducer keeping track of the registered entities.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+
+function entitiesConfig(state = defaultEntities, action) {
+ switch (action.type) {
+ case 'ADD_ENTITIES':
+ return [...state, ...action.entities];
+ }
+
+ return state;
+}
+/**
+ * Reducer keeping track of the registered entities config and data.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+const reducer_entities = (state = {}, action) => {
+ const newConfig = entitiesConfig(state.config, action); // Generates a dynamic reducer for the entities
+
+ let entitiesDataReducer = state.reducer;
+
+ if (!entitiesDataReducer || newConfig !== state.config) {
+ const entitiesByKind = Object(external_lodash_["groupBy"])(newConfig, 'kind');
+ entitiesDataReducer = Object(external_wp_data_["combineReducers"])(Object.entries(entitiesByKind).reduce((memo, [kind, subEntities]) => {
+ const kindReducer = Object(external_wp_data_["combineReducers"])(subEntities.reduce((kindMemo, entityConfig) => ({ ...kindMemo,
+ [entityConfig.name]: reducer_entity(entityConfig)
+ }), {}));
+ memo[kind] = kindReducer;
+ return memo;
+ }, {}));
+ }
+
+ const newData = entitiesDataReducer(state.data, action);
+
+ if (newData === state.data && newConfig === state.config && entitiesDataReducer === state.reducer) {
+ return state;
+ }
+
+ return {
+ reducer: entitiesDataReducer,
+ data: newData,
+ config: newConfig
+ };
+};
+/**
+ * Reducer keeping track of entity edit undo history.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+const UNDO_INITIAL_STATE = [];
+UNDO_INITIAL_STATE.offset = 0;
+let lastEditAction;
+function reducer_undo(state = UNDO_INITIAL_STATE, action) {
+ switch (action.type) {
+ case 'EDIT_ENTITY_RECORD':
+ case 'CREATE_UNDO_LEVEL':
+ let isCreateUndoLevel = action.type === 'CREATE_UNDO_LEVEL';
+ const isUndoOrRedo = !isCreateUndoLevel && (action.meta.isUndo || action.meta.isRedo);
+
+ if (isCreateUndoLevel) {
+ action = lastEditAction;
+ } else if (!isUndoOrRedo) {
+ // Don't lose the last edit cache if the new one only has transient edits.
+ // Transient edits don't create new levels so updating the cache would make
+ // us skip an edit later when creating levels explicitly.
+ if (Object.keys(action.edits).some(key => !action.transientEdits[key])) {
+ lastEditAction = action;
+ } else {
+ lastEditAction = { ...action,
+ edits: { ...(lastEditAction && lastEditAction.edits),
+ ...action.edits
+ }
+ };
+ }
+ }
+
+ let nextState;
+
+ if (isUndoOrRedo) {
+ nextState = [...state];
+ nextState.offset = state.offset + (action.meta.isUndo ? -1 : 1);
+
+ if (state.flattenedUndo) {
+ // The first undo in a sequence of undos might happen while we have
+ // flattened undos in state. If this is the case, we want execution
+ // to continue as if we were creating an explicit undo level. This
+ // will result in an extra undo level being appended with the flattened
+ // undo values.
+ isCreateUndoLevel = true;
+ action = lastEditAction;
+ } else {
+ return nextState;
+ }
+ }
+
+ if (!action.meta.undo) {
+ return state;
+ } // Transient edits don't create an undo level, but are
+ // reachable in the next meaningful edit to which they
+ // are merged. They are defined in the entity's config.
+
+
+ if (!isCreateUndoLevel && !Object.keys(action.edits).some(key => !action.transientEdits[key])) {
+ nextState = [...state];
+ nextState.flattenedUndo = { ...state.flattenedUndo,
+ ...action.edits
+ };
+ nextState.offset = state.offset;
+ return nextState;
+ } // Clear potential redos, because this only supports linear history.
+
+
+ nextState = nextState || state.slice(0, state.offset || undefined);
+ nextState.offset = nextState.offset || 0;
+ nextState.pop();
+
+ if (!isCreateUndoLevel) {
+ nextState.push({
+ kind: action.meta.undo.kind,
+ name: action.meta.undo.name,
+ recordId: action.meta.undo.recordId,
+ edits: { ...state.flattenedUndo,
+ ...action.meta.undo.edits
+ }
+ });
+ } // When an edit is a function it's an optimization to avoid running some expensive operation.
+ // We can't rely on the function references being the same so we opt out of comparing them here.
+
+
+ const comparisonUndoEdits = Object.values(action.meta.undo.edits).filter(edit => typeof edit !== 'function');
+ const comparisonEdits = Object.values(action.edits).filter(edit => typeof edit !== 'function');
+
+ if (!external_wp_isShallowEqual_default()(comparisonUndoEdits, comparisonEdits)) {
+ nextState.push({
+ kind: action.kind,
+ name: action.name,
+ recordId: action.recordId,
+ edits: isCreateUndoLevel ? { ...state.flattenedUndo,
+ ...action.edits
+ } : action.edits
+ });
+ }
+
+ return nextState;
+ }
+
+ return state;
+}
+/**
+ * Reducer managing embed preview data.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function embedPreviews(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_EMBED_PREVIEW':
+ const {
+ url,
+ preview
+ } = action;
+ return { ...state,
+ [url]: preview
+ };
+ }
+
+ return state;
+}
+/**
+ * State which tracks whether the user can perform an action on a REST
+ * resource.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function userPermissions(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_USER_PERMISSION':
+ return { ...state,
+ [action.key]: action.isAllowed
+ };
+ }
+
+ return state;
+}
+/**
+ * Reducer returning autosaves keyed by their parent's post id.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+
+function reducer_autosaves(state = {}, action) {
+ switch (action.type) {
+ case 'RECEIVE_AUTOSAVES':
+ const {
+ postId,
+ autosaves: autosavesData
+ } = action;
+ return { ...state,
+ [postId]: autosavesData
+ };
+ }
+
+ return state;
+}
+/* harmony default export */ var build_module_reducer = (Object(external_wp_data_["combineReducers"])({
+ terms,
+ users: reducer_users,
+ currentTheme,
+ currentUser: reducer_currentUser,
+ taxonomies: reducer_taxonomies,
+ themes,
+ themeSupports,
+ entities: reducer_entities,
+ undo: reducer_undo,
+ embedPreviews,
+ userPermissions,
+ autosaves: reducer_autosaves,
+ locks: locks_reducer
+}));
+
+// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
+var rememo = __webpack_require__("pPDe");
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
+/**
+ * The reducer key used by core data in store registration.
+ * This is defined in a separate file to avoid cycle-dependency
+ *
+ * @type {string}
+ */
+const STORE_NAME = 'core';
+
+// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
+var equivalent_key_map = __webpack_require__("FtRg");
+var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js
+/**
+ * External dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * Cache of state keys to EquivalentKeyMap where the inner map tracks queries
+ * to their resulting items set. WeakMap allows garbage collection on expired
+ * state references.
+ *
+ * @type {WeakMap<Object,EquivalentKeyMap>}
+ */
+
+const queriedItemsCacheByState = new WeakMap();
+/**
+ * Returns items for a given query, or null if the items are not known.
+ *
+ * @param {Object} state State object.
+ * @param {?Object} query Optional query.
+ *
+ * @return {?Array} Query items.
+ */
+
+function getQueriedItemsUncached(state, query) {
+ var _state$queries, _state$queries$contex;
+
+ const {
+ stableKey,
+ page,
+ perPage,
+ include,
+ fields,
+ context
+ } = get_query_parts(query);
+ let itemIds;
+
+ if (Array.isArray(include) && !stableKey) {
+ // If the parsed query yields a set of IDs, but otherwise no filtering,
+ // it's safe to consider targeted item IDs as the include set. This
+ // doesn't guarantee that those objects have been queried, which is
+ // accounted for below in the loop `null` return.
+ itemIds = include; // TODO: Avoid storing the empty stable string in reducer, since it
+ // can be computed dynamically here always.
+ } else if ((_state$queries = state.queries) !== null && _state$queries !== void 0 && (_state$queries$contex = _state$queries[context]) !== null && _state$queries$contex !== void 0 && _state$queries$contex[stableKey]) {
+ itemIds = state.queries[context][stableKey];
+ }
+
+ if (!itemIds) {
+ return null;
+ }
+
+ const startOffset = perPage === -1 ? 0 : (page - 1) * perPage;
+ const endOffset = perPage === -1 ? itemIds.length : Math.min(startOffset + perPage, itemIds.length);
+ const items = [];
+
+ for (let i = startOffset; i < endOffset; i++) {
+ var _state$items$context;
+
+ const itemId = itemIds[i];
+
+ if (Array.isArray(include) && !include.includes(itemId)) {
+ continue;
+ }
+
+ if (!((_state$items$context = state.items[context]) !== null && _state$items$context !== void 0 && _state$items$context.hasOwnProperty(itemId))) {
+ return null;
+ }
+
+ const item = state.items[context][itemId];
+ let filteredItem;
+
+ if (Array.isArray(fields)) {
+ filteredItem = {};
+
+ for (let f = 0; f < fields.length; f++) {
+ const field = fields[f].split('.');
+ const value = Object(external_lodash_["get"])(item, field);
+ Object(external_lodash_["set"])(filteredItem, field, value);
+ }
+ } else {
+ var _state$itemIsComplete;
+
+ // If expecting a complete item, validate that completeness, or
+ // otherwise abort.
+ if (!((_state$itemIsComplete = state.itemIsComplete[context]) !== null && _state$itemIsComplete !== void 0 && _state$itemIsComplete[itemId])) {
+ return null;
+ }
+
+ filteredItem = item;
+ }
+
+ items.push(filteredItem);
+ }
+
+ return items;
+}
+/**
+ * Returns items for a given query, or null if the items are not known. Caches
+ * result both per state (by reference) and per query (by deep equality).
+ * The caching approach is intended to be durable to query objects which are
+ * deeply but not referentially equal, since otherwise:
+ *
+ * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )`
+ *
+ * @param {Object} state State object.
+ * @param {?Object} query Optional query.
+ *
+ * @return {?Array} Query items.
+ */
+
+
+const getQueriedItems = Object(rememo["a" /* default */])((state, query = {}) => {
+ let queriedItemsCache = queriedItemsCacheByState.get(state);
+
+ if (queriedItemsCache) {
+ const queriedItems = queriedItemsCache.get(query);
+
+ if (queriedItems !== undefined) {
+ return queriedItems;
+ }
+ } else {
+ queriedItemsCache = new equivalent_key_map_default.a();
+ queriedItemsCacheByState.set(state, queriedItemsCache);
+ }
+
+ const items = getQueriedItemsUncached(state, query);
+ queriedItemsCache.set(query, items);
+ return items;
+});
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/selectors.js
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Shared reference to an empty array for cases where it is important to avoid
+ * returning a new array reference on every invocation, as in a connected or
+ * other pure component which performs `shouldComponentUpdate` check on props.
+ * This should be used as a last resort, since the normalized data should be
+ * maintained by the reducer result in state.
+ *
+ * @type {Array}
+ */
+
+const EMPTY_ARRAY = [];
+/**
+ * Returns true if a request is in progress for embed preview data, or false
+ * otherwise.
+ *
+ * @param {Object} state Data state.
+ * @param {string} url URL the preview would be for.
+ *
+ * @return {boolean} Whether a request is in progress for an embed preview.
+ */
+
+const isRequestingEmbedPreview = Object(external_wp_data_["createRegistrySelector"])(select => (state, url) => {
+ return select('core/data').isResolving(STORE_NAME, 'getEmbedPreview', [url]);
+});
+/**
+ * Returns all available authors.
+ *
+ * @param {Object} state Data state.
+ * @param {Object|undefined} query Optional object of query parameters to
+ * include with request.
+ * @return {Array} Authors list.
+ */
+
+function getAuthors(state, query) {
+ const path = Object(external_wp_url_["addQueryArgs"])('/wp/v2/users/?who=authors&per_page=100', query);
+ return getUserQueryResults(state, path);
+}
+/**
+ * Returns all available authors.
+ *
+ * @param {Object} state Data state.
+ * @param {number} id The author id.
+ *
+ * @return {Array} Authors list.
+ */
+
+function __unstableGetAuthor(state, id) {
+ return Object(external_lodash_["get"])(state, ['users', 'byId', id], null);
+}
+/**
+ * Returns the current user.
+ *
+ * @param {Object} state Data state.
+ *
+ * @return {Object} Current user object.
+ */
+
+function getCurrentUser(state) {
+ return state.currentUser;
+}
+/**
+ * Returns all the users returned by a query ID.
+ *
+ * @param {Object} state Data state.
+ * @param {string} queryID Query ID.
+ *
+ * @return {Array} Users list.
+ */
+
+const getUserQueryResults = Object(rememo["a" /* default */])((state, queryID) => {
+ const queryResults = state.users.queries[queryID];
+ return Object(external_lodash_["map"])(queryResults, id => state.users.byId[id]);
+}, (state, queryID) => [state.users.queries[queryID], state.users.byId]);
+/**
+ * Returns whether the entities for the give kind are loaded.
+ *
+ * @param {Object} state Data state.
+ * @param {string} kind Entity kind.
+ *
+ * @return {Array<Object>} Array of entities with config matching kind.
+ */
+
+function getEntitiesByKind(state, kind) {
+ return Object(external_lodash_["filter"])(state.entities.config, {
+ kind
+ });
+}
+/**
+ * Returns the entity object given its kind and name.
+ *
+ * @param {Object} state Data state.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ *
+ * @return {Object} Entity
+ */
+
+function getEntity(state, kind, name) {
+ return Object(external_lodash_["find"])(state.entities.config, {
+ kind,
+ name
+ });
+}
+/**
+ * Returns the Entity's record object by key. Returns `null` if the value is not
+ * yet received, undefined if the value entity is known to not exist, or the
+ * entity object if it exists and is received.
+ *
+ * @param {Object} state State tree
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} key Record's key
+ * @param {?Object} query Optional query.
+ *
+ * @return {Object?} Record.
+ */
+
+function getEntityRecord(state, kind, name, key, query) {
+ var _query$context, _queriedState$items$c;
+
+ const queriedState = Object(external_lodash_["get"])(state.entities.data, [kind, name, 'queriedData']);
+
+ if (!queriedState) {
+ return undefined;
+ }
+
+ const context = (_query$context = query === null || query === void 0 ? void 0 : query.context) !== null && _query$context !== void 0 ? _query$context : 'default';
+
+ if (query === undefined) {
+ var _queriedState$itemIsC;
+
+ // If expecting a complete item, validate that completeness.
+ if (!((_queriedState$itemIsC = queriedState.itemIsComplete[context]) !== null && _queriedState$itemIsC !== void 0 && _queriedState$itemIsC[key])) {
+ return undefined;
+ }
+
+ return queriedState.items[context][key];
+ }
+
+ const item = (_queriedState$items$c = queriedState.items[context]) === null || _queriedState$items$c === void 0 ? void 0 : _queriedState$items$c[key];
+
+ if (item && query._fields) {
+ const filteredItem = {};
+ const fields = get_normalized_comma_separable(query._fields);
+
+ for (let f = 0; f < fields.length; f++) {
+ const field = fields[f].split('.');
+ const value = Object(external_lodash_["get"])(item, field);
+ Object(external_lodash_["set"])(filteredItem, field, value);
+ }
+
+ return filteredItem;
+ }
+
+ return item;
+}
+/**
+ * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity from the API if the entity record isn't available in the local state.
+ *
+ * @param {Object} state State tree
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} key Record's key
+ *
+ * @return {Object|null} Record.
+ */
+
+function __experimentalGetEntityRecordNoResolver(state, kind, name, key) {
+ return getEntityRecord(state, kind, name, key);
+}
+/**
+ * Returns the entity's record object by key,
+ * with its attributes mapped to their raw values.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} key Record's key.
+ *
+ * @return {Object?} Object with the entity's raw attributes.
+ */
+
+const getRawEntityRecord = Object(rememo["a" /* default */])((state, kind, name, key) => {
+ const record = getEntityRecord(state, kind, name, key);
+ return record && Object.keys(record).reduce((accumulator, _key) => {
+ // Because edits are the "raw" attribute values,
+ // we return those from record selectors to make rendering,
+ // comparisons, and joins with edits easier.
+ accumulator[_key] = Object(external_lodash_["get"])(record[_key], 'raw', record[_key]);
+ return accumulator;
+ }, {});
+}, state => [state.entities.data]);
+/**
+ * Returns true if records have been received for the given set of parameters,
+ * or false otherwise.
+ *
+ * @param {Object} state State tree
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {?Object} query Optional terms query.
+ *
+ * @return {boolean} Whether entity records have been received.
+ */
+
+function hasEntityRecords(state, kind, name, query) {
+ return Array.isArray(getEntityRecords(state, kind, name, query));
+}
+/**
+ * Returns the Entity's records.
+ *
+ * @param {Object} state State tree
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {?Object} query Optional terms query.
+ *
+ * @return {?Array} Records.
+ */
+
+function getEntityRecords(state, kind, name, query) {
+ // Queried data state is prepopulated for all known entities. If this is not
+ // assigned for the given parameters, then it is known to not exist. Thus, a
+ // return value of an empty array is used instead of `null` (where `null` is
+ // otherwise used to represent an unknown state).
+ const queriedState = Object(external_lodash_["get"])(state.entities.data, [kind, name, 'queriedData']);
+
+ if (!queriedState) {
+ return EMPTY_ARRAY;
+ }
+
+ return getQueriedItems(queriedState, query);
+}
+/**
+ * Returns the list of dirty entity records.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {[{ title: string, key: string, name: string, kind: string }]} The list of updated records
+ */
+
+const __experimentalGetDirtyEntityRecords = Object(rememo["a" /* default */])(state => {
+ const {
+ entities: {
+ data
+ }
+ } = state;
+ const dirtyRecords = [];
+ Object.keys(data).forEach(kind => {
+ Object.keys(data[kind]).forEach(name => {
+ const primaryKeys = Object.keys(data[kind][name].edits).filter(primaryKey => hasEditsForEntityRecord(state, kind, name, primaryKey));
+
+ if (primaryKeys.length) {
+ const entity = getEntity(state, kind, name);
+ primaryKeys.forEach(primaryKey => {
+ var _entity$getTitle;
+
+ const entityRecord = getEditedEntityRecord(state, kind, name, primaryKey);
+ dirtyRecords.push({
+ // We avoid using primaryKey because it's transformed into a string
+ // when it's used as an object key.
+ key: entityRecord[entity.key || DEFAULT_ENTITY_KEY],
+ title: (entity === null || entity === void 0 ? void 0 : (_entity$getTitle = entity.getTitle) === null || _entity$getTitle === void 0 ? void 0 : _entity$getTitle.call(entity, entityRecord)) || '',
+ name,
+ kind
+ });
+ });
+ }
+ });
+ });
+ return dirtyRecords;
+}, state => [state.entities.data]);
+/**
+ * Returns the specified entity record's edits.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {Object?} The entity record's edits.
+ */
+
+function getEntityRecordEdits(state, kind, name, recordId) {
+ return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'edits', recordId]);
+}
+/**
+ * Returns the specified entity record's non transient edits.
+ *
+ * Transient edits don't create an undo level, and
+ * are not considered for change detection.
+ * They are defined in the entity's config.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {Object?} The entity record's non transient edits.
+ */
+
+const getEntityRecordNonTransientEdits = Object(rememo["a" /* default */])((state, kind, name, recordId) => {
+ const {
+ transientEdits
+ } = getEntity(state, kind, name) || {};
+ const edits = getEntityRecordEdits(state, kind, name, recordId) || {};
+
+ if (!transientEdits) {
+ return edits;
+ }
+
+ return Object.keys(edits).reduce((acc, key) => {
+ if (!transientEdits[key]) {
+ acc[key] = edits[key];
+ }
+
+ return acc;
+ }, {});
+}, state => [state.entities.config, state.entities.data]);
+/**
+ * Returns true if the specified entity record has edits,
+ * and false otherwise.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {boolean} Whether the entity record has edits or not.
+ */
+
+function hasEditsForEntityRecord(state, kind, name, recordId) {
+ return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(getEntityRecordNonTransientEdits(state, kind, name, recordId)).length > 0;
+}
+/**
+ * Returns the specified entity record, merged with its edits.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {Object?} The entity record, merged with its edits.
+ */
+
+const getEditedEntityRecord = Object(rememo["a" /* default */])((state, kind, name, recordId) => ({ ...getRawEntityRecord(state, kind, name, recordId),
+ ...getEntityRecordEdits(state, kind, name, recordId)
+}), state => [state.entities.data]);
+/**
+ * Returns true if the specified entity record is autosaving, and false otherwise.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {boolean} Whether the entity record is autosaving or not.
+ */
+
+function isAutosavingEntityRecord(state, kind, name, recordId) {
+ const {
+ pending,
+ isAutosave
+ } = Object(external_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId], {});
+ return Boolean(pending && isAutosave);
+}
+/**
+ * Returns true if the specified entity record is saving, and false otherwise.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {boolean} Whether the entity record is saving or not.
+ */
+
+function isSavingEntityRecord(state, kind, name, recordId) {
+ return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'pending'], false);
+}
+/**
+ * Returns true if the specified entity record is deleting, and false otherwise.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {boolean} Whether the entity record is deleting or not.
+ */
+
+function isDeletingEntityRecord(state, kind, name, recordId) {
+ return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'deleting', recordId, 'pending'], false);
+}
+/**
+ * Returns the specified entity record's last save error.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {Object?} The entity record's save error.
+ */
+
+function getLastEntitySaveError(state, kind, name, recordId) {
+ return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'error']);
+}
+/**
+ * Returns the specified entity record's last delete error.
+ *
+ * @param {Object} state State tree.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number} recordId Record ID.
+ *
+ * @return {Object?} The entity record's save error.
+ */
+
+function getLastEntityDeleteError(state, kind, name, recordId) {
+ return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'deleting', recordId, 'error']);
+}
+/**
+ * Returns the current undo offset for the
+ * entity records edits history. The offset
+ * represents how many items from the end
+ * of the history stack we are at. 0 is the
+ * last edit, -1 is the second last, and so on.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {number} The current undo offset.
+ */
+
+function getCurrentUndoOffset(state) {
+ return state.undo.offset;
+}
+/**
+ * Returns the previous edit from the current undo offset
+ * for the entity records edits history, if any.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {Object?} The edit.
+ */
+
+
+function getUndoEdit(state) {
+ return state.undo[state.undo.length - 2 + getCurrentUndoOffset(state)];
+}
+/**
+ * Returns the next edit from the current undo offset
+ * for the entity records edits history, if any.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {Object?} The edit.
+ */
+
+function getRedoEdit(state) {
+ return state.undo[state.undo.length + getCurrentUndoOffset(state)];
+}
+/**
+ * Returns true if there is a previous edit from the current undo offset
+ * for the entity records edits history, and false otherwise.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {boolean} Whether there is a previous edit or not.
+ */
+
+function hasUndo(state) {
+ return Boolean(getUndoEdit(state));
+}
+/**
+ * Returns true if there is a next edit from the current undo offset
+ * for the entity records edits history, and false otherwise.
+ *
+ * @param {Object} state State tree.
+ *
+ * @return {boolean} Whether there is a next edit or not.
+ */
+
+function hasRedo(state) {
+ return Boolean(getRedoEdit(state));
+}
+/**
+ * Return the current theme.
+ *
+ * @param {Object} state Data state.
+ *
+ * @return {Object} The current theme.
+ */
+
+function getCurrentTheme(state) {
+ return state.themes[state.currentTheme];
+}
+/**
+ * Return theme supports data in the index.
+ *
+ * @param {Object} state Data state.
+ *
+ * @return {*} Index data.
+ */
+
+function getThemeSupports(state) {
+ return state.themeSupports;
+}
+/**
+ * Returns the embed preview for the given URL.
+ *
+ * @param {Object} state Data state.
+ * @param {string} url Embedded URL.
+ *
+ * @return {*} Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API.
+ */
+
+function getEmbedPreview(state, url) {
+ return state.embedPreviews[url];
+}
+/**
+ * Determines if the returned preview is an oEmbed link fallback.
+ *
+ * WordPress can be configured to return a simple link to a URL if it is not embeddable.
+ * We need to be able to determine if a URL is embeddable or not, based on what we
+ * get back from the oEmbed preview API.
+ *
+ * @param {Object} state Data state.
+ * @param {string} url Embedded URL.
+ *
+ * @return {boolean} Is the preview for the URL an oEmbed link fallback.
+ */
+
+function isPreviewEmbedFallback(state, url) {
+ const preview = state.embedPreviews[url];
+ const oEmbedLinkCheck = '<a href="' + url + '">' + url + '</a>';
+
+ if (!preview) {
+ return false;
}
- return arr2;
+ return preview.html === oEmbedLinkCheck;
+}
+/**
+ * Returns whether the current user can perform the given action on the given
+ * REST resource.
+ *
+ * Calling this may trigger an OPTIONS request to the REST API via the
+ * `canUser()` resolver.
+ *
+ * https://developer.wordpress.org/rest-api/reference/
+ *
+ * @param {Object} state Data state.
+ * @param {string} action Action to check. One of: 'create', 'read', 'update', 'delete'.
+ * @param {string} resource REST resource to check, e.g. 'media' or 'posts'.
+ * @param {string=} id Optional ID of the rest resource to check.
+ *
+ * @return {boolean|undefined} Whether or not the user can perform the action,
+ * or `undefined` if the OPTIONS request is still being made.
+ */
+
+function canUser(state, action, resource, id) {
+ const key = Object(external_lodash_["compact"])([action, resource, id]).join('/');
+ return Object(external_lodash_["get"])(state, ['userPermissions', key]);
+}
+/**
+ * Returns whether the current user can edit the given entity.
+ *
+ * Calling this may trigger an OPTIONS request to the REST API via the
+ * `canUser()` resolver.
+ *
+ * https://developer.wordpress.org/rest-api/reference/
+ *
+ * @param {Object} state Data state.
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {string} recordId Record's id.
+ * @return {boolean|undefined} Whether or not the user can edit,
+ * or `undefined` if the OPTIONS request is still being made.
+ */
+
+function canUserEditEntityRecord(state, kind, name, recordId) {
+ const entity = getEntity(state, kind, name);
+
+ if (!entity) {
+ return false;
+ }
+
+ const resource = entity.__unstable_rest_base;
+ return canUser(state, 'update', resource, recordId);
+}
+/**
+ * Returns the latest autosaves for the post.
+ *
+ * May return multiple autosaves since the backend stores one autosave per
+ * author for each post.
+ *
+ * @param {Object} state State tree.
+ * @param {string} postType The type of the parent post.
+ * @param {number} postId The id of the parent post.
+ *
+ * @return {?Array} An array of autosaves for the post, or undefined if there is none.
+ */
+
+function getAutosaves(state, postType, postId) {
+ return state.autosaves[postId];
+}
+/**
+ * Returns the autosave for the post and author.
+ *
+ * @param {Object} state State tree.
+ * @param {string} postType The type of the parent post.
+ * @param {number} postId The id of the parent post.
+ * @param {number} authorId The id of the author.
+ *
+ * @return {?Object} The autosave for the post and author.
+ */
+
+function getAutosave(state, postType, postId, authorId) {
+ if (authorId === undefined) {
+ return;
+ }
+
+ const autosaves = state.autosaves[postId];
+ return Object(external_lodash_["find"])(autosaves, {
+ author: authorId
+ });
+}
+/**
+ * Returns true if the REST request for autosaves has completed.
+ *
+ * @param {Object} state State tree.
+ * @param {string} postType The type of the parent post.
+ * @param {number} postId The id of the parent post.
+ *
+ * @return {boolean} True if the REST request was completed. False otherwise.
+ */
+
+const hasFetchedAutosaves = Object(external_wp_data_["createRegistrySelector"])(select => (state, postType, postId) => {
+ return select(STORE_NAME).hasFinishedResolution('getAutosaves', [postType, postId]);
+});
+/**
+ * Returns a new reference when edited values have changed. This is useful in
+ * inferring where an edit has been made between states by comparison of the
+ * return values using strict equality.
+ *
+ * @example
+ *
+ * ```
+ * const hasEditOccurred = (
+ * getReferenceByDistinctEdits( beforeState ) !==
+ * getReferenceByDistinctEdits( afterState )
+ * );
+ * ```
+ *
+ * @param {Object} state Editor state.
+ *
+ * @return {*} A value whose reference will change only when an edit occurs.
+ */
+
+const getReferenceByDistinctEdits = Object(rememo["a" /* default */])(() => [], state => [state.undo.length, state.undo.offset, state.undo.flattenedUndo]);
+/**
+ * Retrieve the frontend template used for a given link.
+ *
+ * @param {Object} state Editor state.
+ * @param {string} link Link.
+ *
+ * @return {Object?} The template record.
+ */
+
+function __experimentalGetTemplateForLink(state, link) {
+ const records = getEntityRecords(state, 'postType', 'wp_template', {
+ 'find-template': link
+ });
+ const template = records !== null && records !== void 0 && records.length ? records[0] : null;
+
+ if (template) {
+ return getEditedEntityRecord(state, 'postType', 'wp_template', template.id);
+ }
+
+ return template;
+}
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-not-resolved.js
+/**
+ * WordPress dependencies
+ */
+
+/**
+ * Higher-order function which invokes the given resolver only if it has not
+ * already been resolved with the arguments passed to the enhanced function.
+ *
+ * This only considers resolution state, and notably does not support resolver
+ * custom `isFulfilled` behavior.
+ *
+ * @param {Function} resolver Original resolver.
+ * @param {string} selectorName Selector name associated with resolver.
+ *
+ * @return {Function} Enhanced resolver.
+ */
+
+const ifNotResolved = (resolver, selectorName) =>
+/**
+ * @param {...any} args Original resolver arguments.
+ */
+function* resolveIfNotResolved(...args) {
+ const hasStartedResolution = yield external_wp_data_["controls"].select('core', 'hasStartedResolution', selectorName, args);
+
+ if (!hasStartedResolution) {
+ yield* resolver(...args);
+ }
+};
+
+/* harmony default export */ var if_not_resolved = (ifNotResolved);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/resolvers.js
+/**
+ * External dependencies
+ */
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Requests authors from the REST API.
+ *
+ * @param {Object|undefined} query Optional object of query parameters to
+ * include with request.
+ */
+
+function* resolvers_getAuthors(query) {
+ const path = Object(external_wp_url_["addQueryArgs"])('/wp/v2/users/?who=authors&per_page=100', query);
+ const users = yield Object(external_wp_dataControls_["apiFetch"])({
+ path
+ });
+ yield receiveUserQuery(path, users);
+}
+/**
+ * Temporary approach to resolving editor access to author queries.
+ *
+ * @param {number} id The author id.
+ */
+
+function* resolvers_unstableGetAuthor(id) {
+ const path = `/wp/v2/users?who=authors&include=${id}`;
+ const users = yield Object(external_wp_dataControls_["apiFetch"])({
+ path
+ });
+ yield receiveUserQuery('author', users);
+}
+/**
+ * Requests the current user from the REST API.
+ */
+
+function* resolvers_getCurrentUser() {
+ const currentUser = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: '/wp/v2/users/me'
+ });
+ yield receiveCurrentUser(currentUser);
+}
+/**
+ * Requests an entity's record from the REST API.
+ *
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {number|string} key Record's key
+ * @param {Object|undefined} query Optional object of query parameters to
+ * include with request.
+ */
+
+function* resolvers_getEntityRecord(kind, name, key = '', query) {
+ const entities = yield getKindEntities(kind);
+ const entity = Object(external_lodash_["find"])(entities, {
+ kind,
+ name
+ });
+
+ if (!entity) {
+ return;
+ }
+
+ const lock = yield* __unstableAcquireStoreLock('core', ['entities', 'data', kind, name, key], {
+ exclusive: false
+ });
+
+ try {
+ if (query !== undefined && query._fields) {
+ // If requesting specific fields, items and query assocation to said
+ // records are stored by ID reference. Thus, fields must always include
+ // the ID.
+ query = { ...query,
+ _fields: Object(external_lodash_["uniq"])([...(get_normalized_comma_separable(query._fields) || []), entity.key || DEFAULT_ENTITY_KEY]).join()
+ };
+ } // Disable reason: While true that an early return could leave `path`
+ // unused, it's important that path is derived using the query prior to
+ // additional query modifications in the condition below, since those
+ // modifications are relevant to how the data is tracked in state, and not
+ // for how the request is made to the REST API.
+ // eslint-disable-next-line @wordpress/no-unused-vars-before-return
+
+
+ const path = Object(external_wp_url_["addQueryArgs"])(entity.baseURL + '/' + key, { ...entity.baseURLParams,
+ ...query
+ });
+
+ if (query !== undefined) {
+ query = { ...query,
+ include: [key]
+ }; // The resolution cache won't consider query as reusable based on the
+ // fields, so it's tested here, prior to initiating the REST request,
+ // and without causing `getEntityRecords` resolution to occur.
+
+ const hasRecords = yield external_wp_data_["controls"].select('core', 'hasEntityRecords', kind, name, query);
+
+ if (hasRecords) {
+ return;
+ }
+ }
+
+ const record = yield Object(external_wp_dataControls_["apiFetch"])({
+ path
+ });
+ yield receiveEntityRecords(kind, name, record, query);
+ } catch (error) {// We need a way to handle and access REST API errors in state
+ // Until then, catching the error ensures the resolver is marked as resolved.
+ } finally {
+ yield* __unstableReleaseStoreLock(lock);
+ }
+}
+/**
+ * Requests an entity's record from the REST API.
+ */
+
+const resolvers_getRawEntityRecord = if_not_resolved(resolvers_getEntityRecord, 'getEntityRecord');
+/**
+ * Requests an entity's record from the REST API.
+ */
+
+const resolvers_getEditedEntityRecord = if_not_resolved(resolvers_getRawEntityRecord, 'getRawEntityRecord');
+/**
+ * Requests the entity's records from the REST API.
+ *
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {Object?} query Query Object.
+ */
+
+function* resolvers_getEntityRecords(kind, name, query = {}) {
+ const entities = yield getKindEntities(kind);
+ const entity = Object(external_lodash_["find"])(entities, {
+ kind,
+ name
+ });
+
+ if (!entity) {
+ return;
+ }
+
+ const lock = yield* __unstableAcquireStoreLock('core', ['entities', 'data', kind, name], {
+ exclusive: false
+ });
+
+ try {
+ var _query;
+
+ if (query._fields) {
+ // If requesting specific fields, items and query assocation to said
+ // records are stored by ID reference. Thus, fields must always include
+ // the ID.
+ query = { ...query,
+ _fields: Object(external_lodash_["uniq"])([...(get_normalized_comma_separable(query._fields) || []), entity.key || DEFAULT_ENTITY_KEY]).join()
+ };
+ }
+
+ const path = Object(external_wp_url_["addQueryArgs"])(entity.baseURL, { ...entity.baseURLParams,
+ ...query
+ });
+ let records = Object.values(yield Object(external_wp_dataControls_["apiFetch"])({
+ path
+ })); // If we request fields but the result doesn't contain the fields,
+ // explicitely set these fields as "undefined"
+ // that way we consider the query "fullfilled".
+
+ if (query._fields) {
+ records = records.map(record => {
+ query._fields.split(',').forEach(field => {
+ if (!record.hasOwnProperty(field)) {
+ record[field] = undefined;
+ }
+ });
+
+ return record;
+ });
+ }
+
+ yield receiveEntityRecords(kind, name, records, query); // When requesting all fields, the list of results can be used to
+ // resolve the `getEntityRecord` selector in addition to `getEntityRecords`.
+ // See https://github.com/WordPress/gutenberg/pull/26575
+
+ if (!((_query = query) !== null && _query !== void 0 && _query._fields) && !query.context) {
+ const key = entity.key || DEFAULT_ENTITY_KEY;
+ const resolutionsArgs = records.filter(record => record[key]).map(record => [kind, name, record[key]]);
+ yield {
+ type: 'START_RESOLUTIONS',
+ selectorName: 'getEntityRecord',
+ args: resolutionsArgs
+ };
+ yield {
+ type: 'FINISH_RESOLUTIONS',
+ selectorName: 'getEntityRecord',
+ args: resolutionsArgs
+ };
+ }
+ } finally {
+ yield* __unstableReleaseStoreLock(lock);
+ }
+}
+
+resolvers_getEntityRecords.shouldInvalidate = (action, kind, name) => {
+ return (action.type === 'RECEIVE_ITEMS' || action.type === 'REMOVE_ITEMS') && action.invalidateCache && kind === action.kind && name === action.name;
+};
+/**
+ * Requests the current theme.
+ */
+
+
+function* resolvers_getCurrentTheme() {
+ const activeThemes = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: '/wp/v2/themes?status=active'
+ });
+ yield receiveCurrentTheme(activeThemes[0]);
+}
+/**
+ * Requests theme supports data from the index.
+ */
+
+function* resolvers_getThemeSupports() {
+ const activeThemes = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: '/wp/v2/themes?status=active'
+ });
+ yield receiveThemeSupports(activeThemes[0].theme_supports);
+}
+/**
+ * Requests a preview from the from the Embed API.
+ *
+ * @param {string} url URL to get the preview for.
+ */
+
+function* resolvers_getEmbedPreview(url) {
+ try {
+ const embedProxyResponse = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: Object(external_wp_url_["addQueryArgs"])('/oembed/1.0/proxy', {
+ url
+ })
+ });
+ yield receiveEmbedPreview(url, embedProxyResponse);
+ } catch (error) {
+ // Embed API 404s if the URL cannot be embedded, so we have to catch the error from the apiRequest here.
+ yield receiveEmbedPreview(url, false);
+ }
+}
+/**
+ * Checks whether the current user can perform the given action on the given
+ * REST resource.
+ *
+ * @param {string} action Action to check. One of: 'create', 'read', 'update',
+ * 'delete'.
+ * @param {string} resource REST resource to check, e.g. 'media' or 'posts'.
+ * @param {?string} id ID of the rest resource to check.
+ */
+
+function* resolvers_canUser(action, resource, id) {
+ const methods = {
+ create: 'POST',
+ read: 'GET',
+ update: 'PUT',
+ delete: 'DELETE'
+ };
+ const method = methods[action];
+
+ if (!method) {
+ throw new Error(`'${action}' is not a valid action.`);
+ }
+
+ const path = id ? `/wp/v2/${resource}/${id}` : `/wp/v2/${resource}`;
+ let response;
+
+ try {
+ response = yield Object(external_wp_dataControls_["apiFetch"])({
+ path,
+ // Ideally this would always be an OPTIONS request, but unfortunately there's
+ // a bug in the REST API which causes the Allow header to not be sent on
+ // OPTIONS requests to /posts/:id routes.
+ // https://core.trac.wordpress.org/ticket/45753
+ method: id ? 'GET' : 'OPTIONS',
+ parse: false
+ });
+ } catch (error) {
+ // Do nothing if our OPTIONS request comes back with an API error (4xx or
+ // 5xx). The previously determined isAllowed value will remain in the store.
+ return;
+ }
+
+ let allowHeader;
+
+ if (Object(external_lodash_["hasIn"])(response, ['headers', 'get'])) {
+ // If the request is fetched using the fetch api, the header can be
+ // retrieved using the 'get' method.
+ allowHeader = response.headers.get('allow');
+ } else {
+ // If the request was preloaded server-side and is returned by the
+ // preloading middleware, the header will be a simple property.
+ allowHeader = Object(external_lodash_["get"])(response, ['headers', 'Allow'], '');
+ }
+
+ const key = Object(external_lodash_["compact"])([action, resource, id]).join('/');
+ const isAllowed = Object(external_lodash_["includes"])(allowHeader, method);
+ yield receiveUserPermission(key, isAllowed);
+}
+/**
+ * Checks whether the current user can perform the given action on the given
+ * REST resource.
+ *
+ * @param {string} kind Entity kind.
+ * @param {string} name Entity name.
+ * @param {string} recordId Record's id.
+ */
+
+function* resolvers_canUserEditEntityRecord(kind, name, recordId) {
+ const entities = yield getKindEntities(kind);
+ const entity = Object(external_lodash_["find"])(entities, {
+ kind,
+ name
+ });
+
+ if (!entity) {
+ return;
+ }
+
+ const resource = entity.__unstable_rest_base;
+ yield resolvers_canUser('update', resource, recordId);
+}
+/**
+ * Request autosave data from the REST API.
+ *
+ * @param {string} postType The type of the parent post.
+ * @param {number} postId The id of the parent post.
+ */
+
+function* resolvers_getAutosaves(postType, postId) {
+ const {
+ rest_base: restBase
+ } = yield external_wp_data_["controls"].resolveSelect('core', 'getPostType', postType);
+ const autosaves = yield Object(external_wp_dataControls_["apiFetch"])({
+ path: `/wp/v2/${restBase}/${postId}/autosaves?context=edit`
+ });
+
+ if (autosaves && autosaves.length) {
+ yield receiveAutosaves(postId, autosaves);
+ }
+}
+/**
+ * Request autosave data from the REST API.
+ *
+ * This resolver exists to ensure the underlying autosaves are fetched via
+ * `getAutosaves` when a call to the `getAutosave` selector is made.
+ *
+ * @param {string} postType The type of the parent post.
+ * @param {number} postId The id of the parent post.
+ */
+
+function* resolvers_getAutosave(postType, postId) {
+ yield external_wp_data_["controls"].resolveSelect('core', 'getAutosaves', postType, postId);
+}
+/**
+ * Retrieve the frontend template used for a given link.
+ *
+ * @param {string} link Link.
+ */
+
+function* resolvers_experimentalGetTemplateForLink(link) {
+ // Ideally this should be using an apiFetch call
+ // We could potentially do so by adding a "filter" to the `wp_template` end point.
+ // Also it seems the returned object is not a regular REST API post type.
+ let template;
+
+ try {
+ template = yield regularFetch(Object(external_wp_url_["addQueryArgs"])(link, {
+ '_wp-find-template': true
+ }));
+ } catch (e) {// For non-FSE themes, it is possible that this request returns an error.
+ }
+
+ if (!template) {
+ return;
+ }
+
+ yield resolvers_getEntityRecord('postType', 'wp_template', template.id);
+ const record = yield external_wp_data_["controls"].select('core', 'getEntityRecord', 'postType', 'wp_template', template.id);
+
+ if (record) {
+ yield receiveEntityRecords('postType', 'wp_template', [record], {
+ 'find-template': link
+ });
+ }
}
+resolvers_experimentalGetTemplateForLink.shouldInvalidate = action => {
+ return (action.type === 'RECEIVE_ITEMS' || action.type === 'REMOVE_ITEMS') && action.invalidateCache && action.kind === 'postType' && action.name === 'wp_template';
+};
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/locks/selectors.js
+/**
+ * Internal dependencies
+ */
+
+function __unstableGetPendingLockRequests(state) {
+ return state.locks.requests;
+}
+function __unstableIsLockAvailable(state, store, path, {
+ exclusive
+}) {
+ const storePath = [store, ...path];
+ const locks = state.locks.tree; // Validate all parents and the node itself
+
+ for (const node of iteratePath(locks, storePath)) {
+ if (hasConflictingLock({
+ exclusive
+ }, node.locks)) {
+ return false;
+ }
+ } // iteratePath terminates early if path is unreachable, let's
+ // re-fetch the node and check it exists in the tree.
+
+
+ const node = getNode(locks, storePath);
+
+ if (!node) {
+ return true;
+ } // Validate all nested nodes
+
+
+ for (const descendant of iterateDescendants(node)) {
+ if (hasConflictingLock({
+ exclusive
+ }, descendant.locks)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// EXTERNAL MODULE: external ["wp","element"]
+var external_wp_element_ = __webpack_require__("GRId");
+
+// EXTERNAL MODULE: external ["wp","blocks"]
+var external_wp_blocks_ = __webpack_require__("HSyU");
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entity-provider.js
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+const entity_provider_EMPTY_ARRAY = [];
+/**
+ * Internal dependencies
+ */
+
+
+const entity_provider_entities = { ...defaultEntities.reduce((acc, entity) => {
+ if (!acc[entity.kind]) {
+ acc[entity.kind] = {};
+ }
+
+ acc[entity.kind][entity.name] = {
+ context: Object(external_wp_element_["createContext"])()
+ };
+ return acc;
+ }, {}),
+ ...kinds.reduce((acc, kind) => {
+ acc[kind.name] = {};
+ return acc;
+ }, {})
+};
+
+const entity_provider_getEntity = (kind, type) => {
+ if (!entity_provider_entities[kind]) {
+ throw new Error(`Missing entity config for kind: ${kind}.`);
+ }
+
+ if (!entity_provider_entities[kind][type]) {
+ entity_provider_entities[kind][type] = {
+ context: Object(external_wp_element_["createContext"])()
+ };
+ }
+
+ return entity_provider_entities[kind][type];
+};
+/**
+ * Context provider component for providing
+ * an entity for a specific entity type.
+ *
+ * @param {Object} props The component's props.
+ * @param {string} props.kind The entity kind.
+ * @param {string} props.type The entity type.
+ * @param {number} props.id The entity ID.
+ * @param {*} props.children The children to wrap.
+ *
+ * @return {Object} The provided children, wrapped with
+ * the entity's context provider.
+ */
+
+
+function EntityProvider({
+ kind,
+ type,
+ id,
+ children
+}) {
+ const Provider = entity_provider_getEntity(kind, type).context.Provider;
+ return Object(external_wp_element_["createElement"])(Provider, {
+ value: id
+ }, children);
+}
+/**
+ * Hook that returns the ID for the nearest
+ * provided entity of the specified type.
+ *
+ * @param {string} kind The entity kind.
+ * @param {string} type The entity type.
+ */
+
+function useEntityId(kind, type) {
+ return Object(external_wp_element_["useContext"])(entity_provider_getEntity(kind, type).context);
+}
+/**
+ * Hook that returns the value and a setter for the
+ * specified property of the nearest provided
+ * entity of the specified type.
+ *
+ * @param {string} kind The entity kind.
+ * @param {string} type The entity type.
+ * @param {string} prop The property name.
+ * @param {string} [_id] An entity ID to use instead of the context-provided one.
+ *
+ * @return {[*, Function, *]} An array where the first item is the
+ * property value, the second is the
+ * setter and the third is the full value
+ * object from REST API containing more
+ * information like `raw`, `rendered` and
+ * `protected` props.
+ */
+
+function useEntityProp(kind, type, prop, _id) {
+ const providerId = useEntityId(kind, type);
+ const id = _id !== null && _id !== void 0 ? _id : providerId;
+ const {
+ value,
+ fullValue
+ } = Object(external_wp_data_["useSelect"])(select => {
+ const {
+ getEntityRecord,
+ getEditedEntityRecord
+ } = select('core');
+ const entity = getEntityRecord(kind, type, id); // Trigger resolver.
+
+ const editedEntity = getEditedEntityRecord(kind, type, id);
+ return entity && editedEntity ? {
+ value: editedEntity[prop],
+ fullValue: entity[prop]
+ } : {};
+ }, [kind, type, id, prop]);
+ const {
+ editEntityRecord
+ } = Object(external_wp_data_["useDispatch"])('core');
+ const setValue = Object(external_wp_element_["useCallback"])(newValue => {
+ editEntityRecord(kind, type, id, {
+ [prop]: newValue
+ });
+ }, [kind, type, id, prop]);
+ return [value, setValue, fullValue];
+}
+/**
+ * Hook that returns block content getters and setters for
+ * the nearest provided entity of the specified type.
+ *
+ * The return value has the shape `[ blocks, onInput, onChange ]`.
+ * `onInput` is for block changes that don't create undo levels
+ * or dirty the post, non-persistent changes, and `onChange` is for
+ * peristent changes. They map directly to the props of a
+ * `BlockEditorProvider` and are intended to be used with it,
+ * or similar components or hooks.
+ *
+ * @param {string} kind The entity kind.
+ * @param {string} type The entity type.
+ * @param {Object} options
+ * @param {string} [options.id] An entity ID to use instead of the context-provided one.
+ *
+ * @return {[WPBlock[], Function, Function]} The block array and setters.
+ */
+
+function useEntityBlockEditor(kind, type, {
+ id: _id
+} = {}) {
+ const providerId = useEntityId(kind, type);
+ const id = _id !== null && _id !== void 0 ? _id : providerId;
+ const {
+ content,
+ blocks
+ } = Object(external_wp_data_["useSelect"])(select => {
+ const {
+ getEditedEntityRecord
+ } = select('core');
+ const editedEntity = getEditedEntityRecord(kind, type, id);
+ return {
+ blocks: editedEntity.blocks,
+ content: editedEntity.content
+ };
+ }, [kind, type, id]);
+ const {
+ __unstableCreateUndoLevel,
+ editEntityRecord
+ } = Object(external_wp_data_["useDispatch"])('core');
+ Object(external_wp_element_["useEffect"])(() => {
+ // Load the blocks from the content if not already in state
+ // Guard against other instances that might have
+ // set content to a function already or the blocks are already in state.
+ if (content && typeof content !== 'function' && !blocks) {
+ const parsedContent = Object(external_wp_blocks_["parse"])(content);
+ editEntityRecord(kind, type, id, {
+ blocks: parsedContent
+ }, {
+ undoIgnore: true
+ });
+ }
+ }, [content]);
+ const onChange = Object(external_wp_element_["useCallback"])((newBlocks, options) => {
+ const {
+ selection
+ } = options;
+ const edits = {
+ blocks: newBlocks,
+ selection
+ };
+ const noChange = blocks === edits.blocks;
+
+ if (noChange) {
+ return __unstableCreateUndoLevel(kind, type, id);
+ } // We create a new function here on every persistent edit
+ // to make sure the edit makes the post dirty and creates
+ // a new undo level.
+
+
+ edits.content = ({
+ blocks: blocksForSerialization = []
+ }) => Object(external_wp_blocks_["__unstableSerializeAndClean"])(blocksForSerialization);
+
+ editEntityRecord(kind, type, id, edits);
+ }, [kind, type, id, blocks]);
+ const onInput = Object(external_wp_element_["useCallback"])((newBlocks, options) => {
+ const {
+ selection
+ } = options;
+ const edits = {
+ blocks: newBlocks,
+ selection
+ };
+ editEntityRecord(kind, type, id, edits);
+ }, [kind, type, id]);
+ return [blocks !== null && blocks !== void 0 ? blocks : entity_provider_EMPTY_ARRAY, onInput, onChange];
+}
+
+// EXTERNAL MODULE: external ["wp","htmlEntities"]
+var external_wp_htmlEntities_ = __webpack_require__("rmEH");
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/fetch/__experimental-fetch-link-suggestions.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Filters the search by type
+ *
+ * @typedef { 'post' | 'term' | 'post-format' } WPLinkSearchType
+ */
+
+/**
+ * A link with an id may be of kind post-type or taxonomy
+ *
+ * @typedef { 'post-type' | 'taxonomy' } WPKind
+ */
+
+/**
+ * @typedef WPLinkSearchOptions
+ *
+ * @property {boolean} [isInitialSuggestions] Displays initial search suggestions, when true.
+ * @property {WPLinkSearchType} [type] Filters by search type.
+ * @property {string} [subtype] Slug of the post-type or taxonomy.
+ * @property {number} [page] Which page of results to return.
+ * @property {number} [perPage] Search results per page.
+ */
+
+/**
+ * @typedef WPLinkSearchResult
+ *
+ * @property {number} id Post or term id.
+ * @property {string} url Link url.
+ * @property {string} title Title of the link.
+ * @property {string} type The taxonomy or post type slug or type URL.
+ * @property {WPKind} [kind] Link kind of post-type or taxonomy
+ */
+
+/**
+ * @typedef WPEditorSettings
+ *
+ * @property {boolean} [ disablePostFormats ] Disables post formats, when true.
+ */
+
+/**
+ * Fetches link suggestions from the API.
+ *
+ * @async
+ * @param {string} search
+ * @param {WPLinkSearchOptions} [searchOptions]
+ * @param {WPEditorSettings} [settings]
+ *
+ * @example
+ * ```js
+ * import { __experimentalFetchLinkSuggestions as fetchLinkSuggestions } from '@wordpress/core-data';
+ *
+ * //...
+ *
+ * export function initialize( id, settings ) {
+ *
+ * settings.__experimentalFetchLinkSuggestions = (
+ * search,
+ * searchOptions
+ * ) => fetchLinkSuggestions( search, searchOptions, settings );
+ * ```
+ * @return {Promise< WPLinkSearchResult[] >} List of search suggestions
+ */
+
+const fetchLinkSuggestions = async (search, searchOptions = {}, settings = {}) => {
+ const {
+ isInitialSuggestions = false,
+ type = undefined,
+ subtype = undefined,
+ page = undefined,
+ perPage = isInitialSuggestions ? 3 : 20
+ } = searchOptions;
+ const {
+ disablePostFormats = false
+ } = settings;
+ const queries = [];
+
+ if (!type || type === 'post') {
+ queries.push(external_wp_apiFetch_default()({
+ path: Object(external_wp_url_["addQueryArgs"])('/wp/v2/search', {
+ search,
+ page,
+ per_page: perPage,
+ type: 'post',
+ subtype
+ })
+ }).then(results => {
+ return results.map(result => {
+ return { ...result,
+ meta: {
+ kind: 'post-type',
+ subtype
+ }
+ };
+ });
+ }).catch(() => []) // fail by returning no results
+ );
+ }
+
+ if (!type || type === 'term') {
+ queries.push(external_wp_apiFetch_default()({
+ path: Object(external_wp_url_["addQueryArgs"])('/wp/v2/search', {
+ search,
+ page,
+ per_page: perPage,
+ type: 'term',
+ subtype
+ })
+ }).then(results => {
+ return results.map(result => {
+ return { ...result,
+ meta: {
+ kind: 'taxonomy',
+ subtype
+ }
+ };
+ });
+ }).catch(() => []));
+ }
+
+ if (!disablePostFormats && (!type || type === 'post-format')) {
+ queries.push(external_wp_apiFetch_default()({
+ path: Object(external_wp_url_["addQueryArgs"])('/wp/v2/search', {
+ search,
+ page,
+ per_page: perPage,
+ type: 'post-format',
+ subtype
+ })
+ }).then(results => {
+ return results.map(result => {
+ return { ...result,
+ meta: {
+ kind: 'taxonomy',
+ subtype
+ }
+ };
+ });
+ }).catch(() => []));
+ }
+
+ return Promise.all(queries).then(results => {
+ return results.reduce((accumulator, current) => accumulator.concat(current), //flatten list
+ []).filter(
+ /**
+ * @param {{ id: number }} result
+ */
+ result => {
+ return !!result.id;
+ }).slice(0, perPage).map(
+ /**
+ * @param {{ id: number, url:string, title?:string, subtype?: string, type?: string }} result
+ */
+ result => {
+ var _result$meta;
+
+ return {
+ id: result.id,
+ url: result.url,
+ title: Object(external_wp_htmlEntities_["decodeEntities"])(result.title || '') || Object(external_wp_i18n_["__"])('(no title)'),
+ type: result.subtype || result.type,
+ kind: result === null || result === void 0 ? void 0 : (_result$meta = result.meta) === null || _result$meta === void 0 ? void 0 : _result$meta.kind
+ };
+ });
+ });
+};
+
+/* harmony default export */ var _experimental_fetch_link_suggestions = (fetchLinkSuggestions);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/fetch/__experimental-fetch-remote-url-data.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * @typedef WPRemoteUrlData
+ *
+ * @property {string} title contents of the remote URL's `<title>` tag.
+ */
+
+/**
+ * Fetches data about a remote URL.
+ * eg: <title> tag, favicon...etc.
+ *
+ * @async
+ * @param {string} url
+ *
+ * @example
+ * ```js
+ * import { __experimentalFetchRemoteUrlData as fetchRemoteUrlData } from '@wordpress/core-data';
+ *
+ * //...
+ *
+ * export function initialize( id, settings ) {
+ *
+ * settings.__experimentalFetchRemoteUrlData = (
+ * url
+ * ) => fetchRemoteUrlData( url );
+ * ```
+ * @return {Promise< WPRemoteUrlData[] >} Remote URL data.
+ */
+
+const fetchRemoteUrlData = async url => {
+ const endpoint = '/__experimental/url-details';
+ const args = {
+ url: Object(external_wp_url_["prependHTTP"])(url)
+ };
+ return external_wp_apiFetch_default()({
+ path: Object(external_wp_url_["addQueryArgs"])(endpoint, args)
+ });
+};
+
+/* harmony default export */ var _experimental_fetch_remote_url_data = (fetchRemoteUrlData);
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/fetch/index.js
+
+
+
+// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+
+
+
+ // The entity selectors/resolvers and actions are shortcuts to their generic equivalents
+// (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecordss)
+// Instead of getEntityRecord, the consumer could use more user-frieldly named selector: getPostType, getTaxonomy...
+// The "kind" and the "name" of the entity are combined to generate these shortcuts.
+
+const entitySelectors = defaultEntities.reduce((result, entity) => {
+ const {
+ kind,
+ name
+ } = entity;
+
+ result[getMethodName(kind, name)] = (state, key) => getEntityRecord(state, kind, name, key);
+
+ result[getMethodName(kind, name, 'get', true)] = (state, ...args) => getEntityRecords(state, kind, name, ...args);
+
+ return result;
+}, {});
+const entityResolvers = defaultEntities.reduce((result, entity) => {
+ const {
+ kind,
+ name
+ } = entity;
+
+ result[getMethodName(kind, name)] = key => resolvers_getEntityRecord(kind, name, key);
+
+ const pluralMethodName = getMethodName(kind, name, 'get', true);
+
+ result[pluralMethodName] = (...args) => resolvers_getEntityRecords(kind, name, ...args);
+
+ result[pluralMethodName].shouldInvalidate = (action, ...args) => resolvers_getEntityRecords.shouldInvalidate(action, kind, name, ...args);
+
+ return result;
+}, {});
+const entityActions = defaultEntities.reduce((result, entity) => {
+ const {
+ kind,
+ name
+ } = entity;
+
+ result[getMethodName(kind, name, 'save')] = key => saveEntityRecord(kind, name, key);
+
+ result[getMethodName(kind, name, 'delete')] = (key, query) => deleteEntityRecord(kind, name, key, query);
+
+ return result;
+}, {});
+const storeConfig = {
+ reducer: build_module_reducer,
+ controls: { ...build_module_controls,
+ ...external_wp_dataControls_["controls"]
+ },
+ actions: { ...build_module_actions_namespaceObject,
+ ...entityActions,
+ ...locks_actions_namespaceObject
+ },
+ selectors: { ...build_module_selectors_namespaceObject,
+ ...entitySelectors,
+ ...locks_selectors_namespaceObject
+ },
+ resolvers: { ...resolvers_namespaceObject,
+ ...entityResolvers
+ }
+};
+/**
+ * Store definition for the code data namespace.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
+ *
+ * @type {Object}
+ */
+
+const build_module_store = Object(external_wp_data_["createReduxStore"])(STORE_NAME, storeConfig);
+Object(external_wp_data_["register"])(build_module_store);
+
+
+
+
+
/***/ }),
-/***/ 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);
-}
-
-/***/ }),
-
-/***/ 31:
+/***/ "l3Sj":
/***/ (function(module, exports) {
-(function() { module.exports = this["wp"]["url"]; }());
-
-/***/ }),
-
-/***/ 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);
-}
+(function() { module.exports = window["wp"]["i18n"]; }());
/***/ }),
-/***/ 36:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["wp"]["dataControls"]; }());
-
-/***/ }),
-
-/***/ 37:
-/***/ (function(module, exports) {
-
-(function() { module.exports = this["wp"]["deprecated"]; }());
-
-/***/ }),
-
-/***/ 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:
+/***/ "pPDe":
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
@@ -907,3772 +5382,24 @@
/***/ }),
-/***/ 447:
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, "EntityProvider", function() { return /* reexport */ EntityProvider; });
-__webpack_require__.d(__webpack_exports__, "useEntityId", function() { return /* reexport */ useEntityId; });
-__webpack_require__.d(__webpack_exports__, "useEntityProp", function() { return /* reexport */ useEntityProp; });
-__webpack_require__.d(__webpack_exports__, "useEntityBlockEditor", function() { return /* reexport */ useEntityBlockEditor; });
-
-// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/actions.js
-var build_module_actions_namespaceObject = {};
-__webpack_require__.r(build_module_actions_namespaceObject);
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveUserQuery", function() { return receiveUserQuery; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentUser", function() { return receiveCurrentUser; });
-__webpack_require__.d(build_module_actions_namespaceObject, "addEntities", function() { return addEntities; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveEntityRecords", function() { return receiveEntityRecords; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveCurrentTheme", function() { return receiveCurrentTheme; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveThemeSupports", function() { return receiveThemeSupports; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveEmbedPreview", function() { return receiveEmbedPreview; });
-__webpack_require__.d(build_module_actions_namespaceObject, "editEntityRecord", function() { return actions_editEntityRecord; });
-__webpack_require__.d(build_module_actions_namespaceObject, "undo", function() { return undo; });
-__webpack_require__.d(build_module_actions_namespaceObject, "redo", function() { return redo; });
-__webpack_require__.d(build_module_actions_namespaceObject, "__unstableCreateUndoLevel", function() { return __unstableCreateUndoLevel; });
-__webpack_require__.d(build_module_actions_namespaceObject, "saveEntityRecord", function() { return saveEntityRecord; });
-__webpack_require__.d(build_module_actions_namespaceObject, "saveEditedEntityRecord", function() { return saveEditedEntityRecord; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveUploadPermissions", function() { return receiveUploadPermissions; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveUserPermission", function() { return receiveUserPermission; });
-__webpack_require__.d(build_module_actions_namespaceObject, "receiveAutosaves", function() { return receiveAutosaves; });
-
-// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/selectors.js
-var build_module_selectors_namespaceObject = {};
-__webpack_require__.r(build_module_selectors_namespaceObject);
-__webpack_require__.d(build_module_selectors_namespaceObject, "isRequestingEmbedPreview", function() { return isRequestingEmbedPreview; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getAuthors", function() { return getAuthors; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentUser", function() { return getCurrentUser; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getUserQueryResults", function() { return getUserQueryResults; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntitiesByKind", function() { return getEntitiesByKind; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntity", function() { return selectors_getEntity; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecord", function() { return getEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetEntityRecordNoResolver", function() { return __experimentalGetEntityRecordNoResolver; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getRawEntityRecord", function() { return getRawEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecords", function() { return getEntityRecords; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "__experimentalGetDirtyEntityRecords", function() { return __experimentalGetDirtyEntityRecords; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordEdits", function() { return getEntityRecordEdits; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecordNonTransientEdits", function() { return getEntityRecordNonTransientEdits; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "hasEditsForEntityRecord", function() { return hasEditsForEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEditedEntityRecord", function() { return getEditedEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "isAutosavingEntityRecord", function() { return isAutosavingEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "isSavingEntityRecord", function() { return isSavingEntityRecord; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getLastEntitySaveError", function() { return getLastEntitySaveError; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getUndoEdit", function() { return getUndoEdit; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getRedoEdit", function() { return getRedoEdit; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "hasUndo", function() { return hasUndo; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "hasRedo", function() { return hasRedo; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getCurrentTheme", function() { return getCurrentTheme; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getThemeSupports", function() { return getThemeSupports; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getEmbedPreview", function() { return getEmbedPreview; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "isPreviewEmbedFallback", function() { return isPreviewEmbedFallback; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "hasUploadPermissions", function() { return hasUploadPermissions; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "canUser", function() { return canUser; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getAutosaves", function() { return getAutosaves; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getAutosave", function() { return getAutosave; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "hasFetchedAutosaves", function() { return hasFetchedAutosaves; });
-__webpack_require__.d(build_module_selectors_namespaceObject, "getReferenceByDistinctEdits", function() { return getReferenceByDistinctEdits; });
-
-// NAMESPACE OBJECT: ./node_modules/@wordpress/core-data/build-module/resolvers.js
-var resolvers_namespaceObject = {};
-__webpack_require__.r(resolvers_namespaceObject);
-__webpack_require__.d(resolvers_namespaceObject, "getAuthors", function() { return resolvers_getAuthors; });
-__webpack_require__.d(resolvers_namespaceObject, "getCurrentUser", function() { return resolvers_getCurrentUser; });
-__webpack_require__.d(resolvers_namespaceObject, "getEntityRecord", function() { return resolvers_getEntityRecord; });
-__webpack_require__.d(resolvers_namespaceObject, "getRawEntityRecord", function() { return resolvers_getRawEntityRecord; });
-__webpack_require__.d(resolvers_namespaceObject, "getEditedEntityRecord", function() { return resolvers_getEditedEntityRecord; });
-__webpack_require__.d(resolvers_namespaceObject, "getEntityRecords", function() { return resolvers_getEntityRecords; });
-__webpack_require__.d(resolvers_namespaceObject, "getCurrentTheme", function() { return resolvers_getCurrentTheme; });
-__webpack_require__.d(resolvers_namespaceObject, "getThemeSupports", function() { return resolvers_getThemeSupports; });
-__webpack_require__.d(resolvers_namespaceObject, "getEmbedPreview", function() { return resolvers_getEmbedPreview; });
-__webpack_require__.d(resolvers_namespaceObject, "hasUploadPermissions", function() { return resolvers_hasUploadPermissions; });
-__webpack_require__.d(resolvers_namespaceObject, "canUser", function() { return resolvers_canUser; });
-__webpack_require__.d(resolvers_namespaceObject, "getAutosaves", function() { return resolvers_getAutosaves; });
-__webpack_require__.d(resolvers_namespaceObject, "getAutosave", function() { return resolvers_getAutosave; });
-
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
-var defineProperty = __webpack_require__(5);
-
-// EXTERNAL MODULE: external {"this":["wp","data"]}
-var external_this_wp_data_ = __webpack_require__(4);
-
-// 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: external {"this":"lodash"}
-var external_this_lodash_ = __webpack_require__(2);
-
-// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]}
-var external_this_wp_isShallowEqual_ = __webpack_require__(64);
-var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js
-/**
- * A higher-order reducer creator which invokes the original reducer only if
- * the dispatching action matches the given predicate, **OR** if state is
- * initializing (undefined).
- *
- * @param {Function} isMatch Function predicate for allowing reducer call.
- *
- * @return {Function} Higher-order reducer.
- */
-var ifMatchingAction = function ifMatchingAction(isMatch) {
- return function (reducer) {
- return function (state, action) {
- if (state === undefined || isMatch(action)) {
- return reducer(state, action);
- }
-
- return state;
- };
- };
-};
-
-/* harmony default export */ var if_matching_action = (ifMatchingAction);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js
-/**
- * Higher-order reducer creator which substitutes the action object before
- * passing to the original reducer.
- *
- * @param {Function} replacer Function mapping original action to replacement.
- *
- * @return {Function} Higher-order reducer.
- */
-var replaceAction = function replaceAction(replacer) {
- return function (reducer) {
- return function (state, action) {
- return reducer(state, replacer(action));
- };
- };
-};
-
-/* harmony default export */ var replace_action = (replaceAction);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/conservative-map-item.js
-/**
- * External dependencies
- */
-
-/**
- * Given the current and next item entity, returns the minimally "modified"
- * result of the next item, preferring value references from the original item
- * if equal. If all values match, the original item is returned.
- *
- * @param {Object} item Original item.
- * @param {Object} nextItem Next item.
- *
- * @return {Object} Minimally modified merged item.
- */
-
-function conservativeMapItem(item, nextItem) {
- // Return next item in its entirety if there is no original item.
- if (!item) {
- return nextItem;
- }
-
- var hasChanges = false;
- var result = {};
-
- for (var key in nextItem) {
- if (Object(external_this_lodash_["isEqual"])(item[key], nextItem[key])) {
- result[key] = item[key];
- } else {
- hasChanges = true;
- result[key] = nextItem[key];
- }
- }
-
- if (!hasChanges) {
- return item;
- }
-
- return result;
-}
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.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; }
-
-/**
- * Higher-order reducer creator which creates a combined reducer object, keyed
- * by a property on the action object.
- *
- * @param {string} actionProperty Action property by which to key object.
- *
- * @return {Function} Higher-order reducer.
- */
-var on_sub_key_onSubKey = function onSubKey(actionProperty) {
- return function (reducer) {
- return function () {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
- // Retrieve subkey from action. Do not track if undefined; useful for cases
- // where reducer is scoped by action shape.
- var key = action[actionProperty];
-
- if (key === undefined) {
- return state;
- } // Avoid updating state if unchanged. Note that this also accounts for a
- // reducer which returns undefined on a key which is not yet tracked.
-
-
- var nextKeyState = reducer(state[key], action);
-
- if (nextKeyState === state[key]) {
- return state;
- }
-
- return _objectSpread({}, state, Object(defineProperty["a" /* default */])({}, key, nextKeyState));
- };
- };
-};
-/* harmony default export */ var on_sub_key = (on_sub_key_onSubKey);
-
-// EXTERNAL MODULE: external {"this":"regeneratorRuntime"}
-var external_this_regeneratorRuntime_ = __webpack_require__(24);
-var external_this_regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(external_this_regeneratorRuntime_);
-
-// EXTERNAL MODULE: external {"this":["wp","i18n"]}
-var external_this_wp_i18n_ = __webpack_require__(1);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js
-
-
-function actions_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 actions_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { actions_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 { actions_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * External dependencies
- */
-
-/**
- * Returns an action object used in signalling that items have been received.
- *
- * @param {Array} items Items received.
- *
- * @return {Object} Action object.
- */
-
-function receiveItems(items) {
- return {
- type: 'RECEIVE_ITEMS',
- items: Object(external_this_lodash_["castArray"])(items)
- };
-}
-/**
- * Returns an action object used in signalling that queried data has been
- * received.
- *
- * @param {Array} items Queried items received.
- * @param {?Object} query Optional query object.
- *
- * @return {Object} Action object.
- */
-
-function receiveQueriedItems(items) {
- var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
- return actions_objectSpread({}, receiveItems(items), {
- query: query
- });
-}
-
-// EXTERNAL MODULE: external {"this":["wp","apiFetch"]}
-var external_this_wp_apiFetch_ = __webpack_require__(45);
-var external_this_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_apiFetch_);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/controls.js
-
-
-/**
- * WordPress dependencies
- */
-
-
-/**
- * Trigger an API Fetch request.
- *
- * @param {Object} request API Fetch Request Object.
- * @return {Object} control descriptor.
- */
-
-function apiFetch(request) {
- return {
- type: 'API_FETCH',
- request: request
- };
-}
-/**
- * Calls a selector using the current state.
- *
- * @param {string} selectorName Selector name.
- * @param {Array} args Selector arguments.
- *
- * @return {Object} control descriptor.
- */
-
-function controls_select(selectorName) {
- for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
- args[_key - 1] = arguments[_key];
- }
-
- return {
- type: 'SELECT',
- selectorName: selectorName,
- args: args
- };
-}
-/**
- * Dispatches a control action for triggering a registry select that has a
- * resolver.
- *
- * @param {string} selectorName
- * @param {Array} args Arguments for the select.
- *
- * @return {Object} control descriptor.
- */
-
-function resolveSelect(selectorName) {
- for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
- args[_key2 - 1] = arguments[_key2];
- }
-
- return {
- type: 'RESOLVE_SELECT',
- selectorName: selectorName,
- args: args
- };
-}
-var controls = {
- API_FETCH: function API_FETCH(_ref) {
- var request = _ref.request;
- return external_this_wp_apiFetch_default()(request);
- },
- SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) {
- return function (_ref2) {
- var _registry$select;
-
- var selectorName = _ref2.selectorName,
- args = _ref2.args;
- return (_registry$select = registry.select('core'))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args));
- };
- }),
- RESOLVE_SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) {
- return function (_ref3) {
- var _registry$__experimen;
-
- var selectorName = _ref3.selectorName,
- args = _ref3.args;
- return (_registry$__experimen = registry.__experimentalResolveSelect('core'))[selectorName].apply(_registry$__experimen, Object(toConsumableArray["a" /* default */])(args));
- };
- })
-};
-/* harmony default export */ var build_module_controls = (controls);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/actions.js
-
-
-
-
-var _marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(actions_editEntityRecord),
- _marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(undo),
- _marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(redo),
- _marked4 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(saveEntityRecord),
- _marked5 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(saveEditedEntityRecord);
-
-function build_module_actions_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 build_module_actions_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_actions_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 { build_module_actions_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * External dependencies
- */
-
-/**
- * Internal dependencies
- */
-
-
-
-
-/**
- * Returns an action object used in signalling that authors have been received.
- *
- * @param {string} queryID Query ID.
- * @param {Array|Object} users Users received.
- *
- * @return {Object} Action object.
- */
-
-function receiveUserQuery(queryID, users) {
- return {
- type: 'RECEIVE_USER_QUERY',
- users: Object(external_this_lodash_["castArray"])(users),
- queryID: queryID
- };
-}
-/**
- * Returns an action used in signalling that the current user has been received.
- *
- * @param {Object} currentUser Current user object.
- *
- * @return {Object} Action object.
- */
-
-function receiveCurrentUser(currentUser) {
- return {
- type: 'RECEIVE_CURRENT_USER',
- currentUser: currentUser
- };
-}
-/**
- * Returns an action object used in adding new entities.
- *
- * @param {Array} entities Entities received.
- *
- * @return {Object} Action object.
- */
-
-function addEntities(entities) {
- return {
- type: 'ADD_ENTITIES',
- entities: entities
- };
-}
-/**
- * Returns an action object used in signalling that entity records have been received.
- *
- * @param {string} kind Kind of the received entity.
- * @param {string} name Name of the received entity.
- * @param {Array|Object} records Records received.
- * @param {?Object} query Query Object.
- * @param {?boolean} invalidateCache Should invalidate query caches
- *
- * @return {Object} Action object.
- */
-
-function receiveEntityRecords(kind, name, records, query) {
- var invalidateCache = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-
- // Auto drafts should not have titles, but some plugins rely on them so we can't filter this
- // on the server.
- if (kind === 'postType') {
- records = Object(external_this_lodash_["castArray"])(records).map(function (record) {
- return record.status === 'auto-draft' ? build_module_actions_objectSpread({}, record, {
- title: ''
- }) : record;
- });
- }
-
- var action;
-
- if (query) {
- action = receiveQueriedItems(records, query);
- } else {
- action = receiveItems(records);
- }
-
- return build_module_actions_objectSpread({}, action, {
- kind: kind,
- name: name,
- invalidateCache: invalidateCache
- });
-}
-/**
- * Returns an action object used in signalling that the current theme has been received.
- *
- * @param {Object} currentTheme The current theme.
- *
- * @return {Object} Action object.
- */
-
-function receiveCurrentTheme(currentTheme) {
- return {
- type: 'RECEIVE_CURRENT_THEME',
- currentTheme: currentTheme
- };
-}
-/**
- * Returns an action object used in signalling that the index has been received.
- *
- * @param {Object} themeSupports Theme support for the current theme.
- *
- * @return {Object} Action object.
- */
-
-function receiveThemeSupports(themeSupports) {
- return {
- type: 'RECEIVE_THEME_SUPPORTS',
- themeSupports: themeSupports
- };
-}
-/**
- * Returns an action object used in signalling that the preview data for
- * a given URl has been received.
- *
- * @param {string} url URL to preview the embed for.
- * @param {*} preview Preview data.
- *
- * @return {Object} Action object.
- */
-
-function receiveEmbedPreview(url, preview) {
- return {
- type: 'RECEIVE_EMBED_PREVIEW',
- url: url,
- preview: preview
- };
-}
-/**
- * Returns an action object that triggers an
- * edit to an entity record.
- *
- * @param {string} kind Kind of the edited entity record.
- * @param {string} name Name of the edited entity record.
- * @param {number} recordId Record ID of the edited entity record.
- * @param {Object} edits The edits.
- * @param {Object} options Options for the edit.
- * @param {boolean} options.undoIgnore Whether to ignore the edit in undo history or not.
- *
- * @return {Object} Action object.
- */
-
-function actions_editEntityRecord(kind, name, recordId, edits) {
- var options,
- entity,
- _entity$transientEdit,
- transientEdits,
- _entity$mergedEdits,
- mergedEdits,
- record,
- editedRecord,
- edit,
- _args = arguments;
-
- return external_this_regeneratorRuntime_default.a.wrap(function editEntityRecord$(_context) {
- while (1) {
- switch (_context.prev = _context.next) {
- case 0:
- options = _args.length > 4 && _args[4] !== undefined ? _args[4] : {};
- _context.next = 3;
- return controls_select('getEntity', kind, name);
-
- case 3:
- entity = _context.sent;
-
- if (entity) {
- _context.next = 6;
- break;
- }
-
- throw new Error("The entity being edited (".concat(kind, ", ").concat(name, ") does not have a loaded config."));
-
- case 6:
- _entity$transientEdit = entity.transientEdits, transientEdits = _entity$transientEdit === void 0 ? {} : _entity$transientEdit, _entity$mergedEdits = entity.mergedEdits, mergedEdits = _entity$mergedEdits === void 0 ? {} : _entity$mergedEdits;
- _context.next = 9;
- return controls_select('getRawEntityRecord', kind, name, recordId);
-
- case 9:
- record = _context.sent;
- _context.next = 12;
- return controls_select('getEditedEntityRecord', kind, name, recordId);
-
- case 12:
- editedRecord = _context.sent;
- edit = {
- kind: kind,
- name: name,
- recordId: recordId,
- // Clear edits when they are equal to their persisted counterparts
- // so that the property is not considered dirty.
- edits: Object.keys(edits).reduce(function (acc, key) {
- var recordValue = record[key];
- var editedRecordValue = editedRecord[key];
- var value = mergedEdits[key] ? build_module_actions_objectSpread({}, editedRecordValue, {}, edits[key]) : edits[key];
- acc[key] = Object(external_this_lodash_["isEqual"])(recordValue, value) ? undefined : value;
- return acc;
- }, {}),
- transientEdits: transientEdits
- };
- return _context.abrupt("return", build_module_actions_objectSpread({
- type: 'EDIT_ENTITY_RECORD'
- }, edit, {
- meta: {
- undo: !options.undoIgnore && build_module_actions_objectSpread({}, edit, {
- // Send the current values for things like the first undo stack entry.
- edits: Object.keys(edits).reduce(function (acc, key) {
- acc[key] = editedRecord[key];
- return acc;
- }, {})
- })
- }
- }));
-
- case 15:
- case "end":
- return _context.stop();
- }
- }
- }, _marked);
-}
-/**
- * Action triggered to undo the last edit to
- * an entity record, if any.
- */
-
-function undo() {
- var undoEdit;
- return external_this_regeneratorRuntime_default.a.wrap(function undo$(_context2) {
- while (1) {
- switch (_context2.prev = _context2.next) {
- case 0:
- _context2.next = 2;
- return controls_select('getUndoEdit');
-
- case 2:
- undoEdit = _context2.sent;
-
- if (undoEdit) {
- _context2.next = 5;
- break;
- }
-
- return _context2.abrupt("return");
-
- case 5:
- _context2.next = 7;
- return build_module_actions_objectSpread({
- type: 'EDIT_ENTITY_RECORD'
- }, undoEdit, {
- meta: {
- isUndo: true
- }
- });
-
- case 7:
- case "end":
- return _context2.stop();
- }
- }
- }, _marked2);
-}
-/**
- * Action triggered to redo the last undoed
- * edit to an entity record, if any.
- */
-
-function redo() {
- var redoEdit;
- return external_this_regeneratorRuntime_default.a.wrap(function redo$(_context3) {
- while (1) {
- switch (_context3.prev = _context3.next) {
- case 0:
- _context3.next = 2;
- return controls_select('getRedoEdit');
-
- case 2:
- redoEdit = _context3.sent;
-
- if (redoEdit) {
- _context3.next = 5;
- break;
- }
-
- return _context3.abrupt("return");
-
- case 5:
- _context3.next = 7;
- return build_module_actions_objectSpread({
- type: 'EDIT_ENTITY_RECORD'
- }, redoEdit, {
- meta: {
- isRedo: true
- }
- });
-
- case 7:
- case "end":
- return _context3.stop();
- }
- }
- }, _marked3);
-}
-/**
- * Forces the creation of a new undo level.
- *
- * @return {Object} Action object.
- */
-
-function __unstableCreateUndoLevel() {
- return {
- type: 'CREATE_UNDO_LEVEL'
- };
-}
-/**
- * Action triggered to save an entity record.
- *
- * @param {string} kind Kind of the received entity.
- * @param {string} name Name of the received entity.
- * @param {Object} record Record to be saved.
- * @param {Object} options Saving options.
- * @param {boolean} [options.isAutosave=false] Whether this is an autosave.
- */
-
-function saveEntityRecord(kind, name, record) {
- var _ref,
- _ref$isAutosave,
- isAutosave,
- entities,
- entity,
- entityIdKey,
- recordId,
- _i,
- _Object$entries,
- _Object$entries$_i,
- key,
- value,
- evaluatedValue,
- updatedRecord,
- error,
- persistedEntity,
- currentEdits,
- path,
- persistedRecord,
- currentUser,
- currentUserId,
- autosavePost,
- data,
- newRecord,
- _data,
- _args4 = arguments;
-
- return external_this_regeneratorRuntime_default.a.wrap(function saveEntityRecord$(_context4) {
- while (1) {
- switch (_context4.prev = _context4.next) {
- case 0:
- _ref = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {
- isAutosave: false
- }, _ref$isAutosave = _ref.isAutosave, isAutosave = _ref$isAutosave === void 0 ? false : _ref$isAutosave;
- _context4.next = 3;
- return getKindEntities(kind);
-
- case 3:
- entities = _context4.sent;
- entity = Object(external_this_lodash_["find"])(entities, {
- kind: kind,
- name: name
- });
-
- if (entity) {
- _context4.next = 7;
- break;
- }
-
- return _context4.abrupt("return");
-
- case 7:
- entityIdKey = entity.key || DEFAULT_ENTITY_KEY;
- recordId = record[entityIdKey]; // Evaluate optimized edits.
- // (Function edits that should be evaluated on save to avoid expensive computations on every edit.)
-
- _i = 0, _Object$entries = Object.entries(record);
-
- case 10:
- if (!(_i < _Object$entries.length)) {
- _context4.next = 24;
- break;
- }
-
- _Object$entries$_i = Object(slicedToArray["a" /* default */])(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
-
- if (!(typeof value === 'function')) {
- _context4.next = 21;
- break;
- }
-
- _context4.t0 = value;
- _context4.next = 16;
- return controls_select('getEditedEntityRecord', kind, name, recordId);
-
- case 16:
- _context4.t1 = _context4.sent;
- evaluatedValue = (0, _context4.t0)(_context4.t1);
- _context4.next = 20;
- return actions_editEntityRecord(kind, name, recordId, Object(defineProperty["a" /* default */])({}, key, evaluatedValue), {
- undoIgnore: true
- });
-
- case 20:
- record[key] = evaluatedValue;
-
- case 21:
- _i++;
- _context4.next = 10;
- break;
-
- case 24:
- _context4.next = 26;
- return {
- type: 'SAVE_ENTITY_RECORD_START',
- kind: kind,
- name: name,
- recordId: recordId,
- isAutosave: isAutosave
- };
-
- case 26:
- _context4.prev = 26;
- path = "".concat(entity.baseURL).concat(recordId ? '/' + recordId : '');
- _context4.next = 30;
- return controls_select('getRawEntityRecord', kind, name, recordId);
-
- case 30:
- persistedRecord = _context4.sent;
-
- if (!isAutosave) {
- _context4.next = 55;
- break;
- }
-
- _context4.next = 34;
- return controls_select('getCurrentUser');
-
- case 34:
- currentUser = _context4.sent;
- currentUserId = currentUser ? currentUser.id : undefined;
- _context4.next = 38;
- return controls_select('getAutosave', persistedRecord.type, persistedRecord.id, currentUserId);
-
- case 38:
- autosavePost = _context4.sent;
- // Autosaves need all expected fields to be present.
- // So we fallback to the previous autosave and then
- // to the actual persisted entity if the edits don't
- // have a value.
- data = build_module_actions_objectSpread({}, persistedRecord, {}, autosavePost, {}, record);
- data = Object.keys(data).reduce(function (acc, key) {
- if (['title', 'excerpt', 'content'].includes(key)) {
- // Edits should be the "raw" attribute values.
- acc[key] = Object(external_this_lodash_["get"])(data[key], 'raw', data[key]);
- }
-
- return acc;
- }, {
- status: data.status === 'auto-draft' ? 'draft' : data.status
- });
- _context4.next = 43;
- return apiFetch({
- path: "".concat(path, "/autosaves"),
- method: 'POST',
- data: data
- });
-
- case 43:
- updatedRecord = _context4.sent;
-
- if (!(persistedRecord.id === updatedRecord.id)) {
- _context4.next = 51;
- break;
- }
-
- newRecord = build_module_actions_objectSpread({}, persistedRecord, {}, data, {}, updatedRecord);
- newRecord = Object.keys(newRecord).reduce(function (acc, key) {
- // These properties are persisted in autosaves.
- if (['title', 'excerpt', 'content'].includes(key)) {
- // Edits should be the "raw" attribute values.
- acc[key] = Object(external_this_lodash_["get"])(newRecord[key], 'raw', newRecord[key]);
- } else if (key === 'status') {
- // Status is only persisted in autosaves when going from
- // "auto-draft" to "draft".
- acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status;
- } else {
- // These properties are not persisted in autosaves.
- acc[key] = Object(external_this_lodash_["get"])(persistedRecord[key], 'raw', persistedRecord[key]);
- }
-
- return acc;
- }, {});
- _context4.next = 49;
- return receiveEntityRecords(kind, name, newRecord, undefined, true);
-
- case 49:
- _context4.next = 53;
- break;
-
- case 51:
- _context4.next = 53;
- return receiveAutosaves(persistedRecord.id, updatedRecord);
-
- case 53:
- _context4.next = 70;
- break;
-
- case 55:
- // Auto drafts should be converted to drafts on explicit saves and we should not respect their default title,
- // but some plugins break with this behavior so we can't filter it on the server.
- _data = record;
-
- if (kind === 'postType' && persistedRecord && persistedRecord.status === 'auto-draft') {
- if (!_data.status) {
- _data = build_module_actions_objectSpread({}, _data, {
- status: 'draft'
- });
- }
-
- if (!_data.title || _data.title === 'Auto Draft') {
- _data = build_module_actions_objectSpread({}, _data, {
- title: ''
- });
- }
- } // Get the full local version of the record before the update,
- // to merge it with the edits and then propagate it to subscribers
-
-
- _context4.next = 59;
- return controls_select('__experimentalGetEntityRecordNoResolver', kind, name, recordId);
-
- case 59:
- persistedEntity = _context4.sent;
- _context4.next = 62;
- return controls_select('getEntityRecordEdits', kind, name, recordId);
-
- case 62:
- currentEdits = _context4.sent;
- _context4.next = 65;
- return receiveEntityRecords(kind, name, build_module_actions_objectSpread({}, persistedEntity, {}, _data), undefined, true);
-
- case 65:
- _context4.next = 67;
- return apiFetch({
- path: path,
- method: recordId ? 'PUT' : 'POST',
- data: _data
- });
-
- case 67:
- updatedRecord = _context4.sent;
- _context4.next = 70;
- return receiveEntityRecords(kind, name, updatedRecord, undefined, true);
-
- case 70:
- _context4.next = 93;
- break;
-
- case 72:
- _context4.prev = 72;
- _context4.t2 = _context4["catch"](26);
- error = _context4.t2; // If we got to the point in the try block where we made an optimistic update,
- // we need to roll it back here.
-
- if (!(persistedEntity && currentEdits)) {
- _context4.next = 93;
- break;
- }
-
- _context4.next = 78;
- return receiveEntityRecords(kind, name, persistedEntity, undefined, true);
-
- case 78:
- _context4.t3 = actions_editEntityRecord;
- _context4.t4 = kind;
- _context4.t5 = name;
- _context4.t6 = recordId;
- _context4.t7 = build_module_actions_objectSpread;
- _context4.t8 = {};
- _context4.t9 = currentEdits;
- _context4.t10 = {};
- _context4.next = 88;
- return controls_select('getEntityRecordEdits', kind, name, recordId);
-
- case 88:
- _context4.t11 = _context4.sent;
- _context4.t12 = (0, _context4.t7)(_context4.t8, _context4.t9, _context4.t10, _context4.t11);
- _context4.t13 = {
- undoIgnore: true
- };
- _context4.next = 93;
- return (0, _context4.t3)(_context4.t4, _context4.t5, _context4.t6, _context4.t12, _context4.t13);
-
- case 93:
- _context4.next = 95;
- return {
- type: 'SAVE_ENTITY_RECORD_FINISH',
- kind: kind,
- name: name,
- recordId: recordId,
- error: error,
- isAutosave: isAutosave
- };
-
- case 95:
- return _context4.abrupt("return", updatedRecord);
-
- case 96:
- case "end":
- return _context4.stop();
- }
- }
- }, _marked4, null, [[26, 72]]);
-}
-/**
- * Action triggered to save an entity record's edits.
- *
- * @param {string} kind Kind of the entity.
- * @param {string} name Name of the entity.
- * @param {Object} recordId ID of the record.
- * @param {Object} options Saving options.
- */
-
-function saveEditedEntityRecord(kind, name, recordId, options) {
- var edits, record;
- return external_this_regeneratorRuntime_default.a.wrap(function saveEditedEntityRecord$(_context5) {
- while (1) {
- switch (_context5.prev = _context5.next) {
- case 0:
- _context5.next = 2;
- return controls_select('hasEditsForEntityRecord', kind, name, recordId);
-
- case 2:
- if (_context5.sent) {
- _context5.next = 4;
- break;
- }
-
- return _context5.abrupt("return");
-
- case 4:
- _context5.next = 6;
- return controls_select('getEntityRecordNonTransientEdits', kind, name, recordId);
-
- case 6:
- edits = _context5.sent;
- record = build_module_actions_objectSpread({
- id: recordId
- }, edits);
- return _context5.delegateYield(saveEntityRecord(kind, name, record, options), "t0", 9);
-
- case 9:
- case "end":
- return _context5.stop();
- }
- }
- }, _marked5);
-}
-/**
- * Returns an action object used in signalling that Upload permissions have been received.
- *
- * @param {boolean} hasUploadPermissions Does the user have permission to upload files?
- *
- * @return {Object} Action object.
- */
-
-function receiveUploadPermissions(hasUploadPermissions) {
- return {
- type: 'RECEIVE_USER_PERMISSION',
- key: 'create/media',
- isAllowed: hasUploadPermissions
- };
-}
-/**
- * Returns an action object used in signalling that the current user has
- * permission to perform an action on a REST resource.
- *
- * @param {string} key A key that represents the action and REST resource.
- * @param {boolean} isAllowed Whether or not the user can perform the action.
- *
- * @return {Object} Action object.
- */
-
-function receiveUserPermission(key, isAllowed) {
- return {
- type: 'RECEIVE_USER_PERMISSION',
- key: key,
- isAllowed: isAllowed
- };
-}
-/**
- * Returns an action object used in signalling that the autosaves for a
- * post have been received.
- *
- * @param {number} postId The id of the post that is parent to the autosave.
- * @param {Array|Object} autosaves An array of autosaves or singular autosave object.
- *
- * @return {Object} Action object.
- */
-
-function receiveAutosaves(postId, autosaves) {
- return {
- type: 'RECEIVE_AUTOSAVES',
- postId: postId,
- autosaves: Object(external_this_lodash_["castArray"])(autosaves)
- };
-}
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js
-
-
-var entities_marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(loadPostTypeEntities),
- entities_marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(loadTaxonomyEntities),
- entities_marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(getKindEntities);
-
-/**
- * External dependencies
- */
-
-/**
- * WordPress dependencies
- */
-
-
-/**
- * Internal dependencies
- */
-
-
-
-var DEFAULT_ENTITY_KEY = 'id';
-var defaultEntities = [{
- label: Object(external_this_wp_i18n_["__"])('Site'),
- name: 'site',
- kind: 'root',
- baseURL: '/wp/v2/settings',
- getTitle: function getTitle(record) {
- return Object(external_this_lodash_["get"])(record, ['title'], Object(external_this_wp_i18n_["__"])('Site Title'));
- }
-}, {
- label: Object(external_this_wp_i18n_["__"])('Post Type'),
- name: 'postType',
- kind: 'root',
- key: 'slug',
- baseURL: '/wp/v2/types'
-}, {
- name: 'media',
- kind: 'root',
- baseURL: '/wp/v2/media',
- plural: 'mediaItems',
- label: Object(external_this_wp_i18n_["__"])('Media')
-}, {
- name: 'taxonomy',
- kind: 'root',
- key: 'slug',
- baseURL: '/wp/v2/taxonomies',
- plural: 'taxonomies',
- label: Object(external_this_wp_i18n_["__"])('Taxonomy')
-}, {
- name: 'widgetArea',
- kind: 'root',
- baseURL: '/__experimental/widget-areas',
- plural: 'widgetAreas',
- transientEdits: {
- blocks: true
- },
- label: Object(external_this_wp_i18n_["__"])('Widget area')
-}, {
- label: Object(external_this_wp_i18n_["__"])('User'),
- name: 'user',
- kind: 'root',
- baseURL: '/wp/v2/users',
- plural: 'users'
-}, {
- name: 'comment',
- kind: 'root',
- baseURL: '/wp/v2/comments',
- plural: 'comments',
- label: Object(external_this_wp_i18n_["__"])('Comment')
-}, {
- name: 'menu',
- kind: 'root',
- baseURL: '/__experimental/menus',
- plural: 'menus',
- label: Object(external_this_wp_i18n_["__"])('Menu')
-}, {
- name: 'menuItem',
- kind: 'root',
- baseURL: '/__experimental/menu-items',
- plural: 'menuItems',
- label: Object(external_this_wp_i18n_["__"])('Menu Item')
-}, {
- name: 'menuLocation',
- kind: 'root',
- baseURL: '/__experimental/menu-locations',
- plural: 'menuLocations',
- label: Object(external_this_wp_i18n_["__"])('Menu Location'),
- key: 'name'
-}];
-var kinds = [{
- name: 'postType',
- loadEntities: loadPostTypeEntities
-}, {
- name: 'taxonomy',
- loadEntities: loadTaxonomyEntities
-}];
-/**
- * Returns the list of post type entities.
- *
- * @return {Promise} Entities promise
- */
-
-function loadPostTypeEntities() {
- var postTypes;
- return external_this_regeneratorRuntime_default.a.wrap(function loadPostTypeEntities$(_context) {
- while (1) {
- switch (_context.prev = _context.next) {
- case 0:
- _context.next = 2;
- return apiFetch({
- path: '/wp/v2/types?context=edit'
- });
-
- case 2:
- postTypes = _context.sent;
- return _context.abrupt("return", Object(external_this_lodash_["map"])(postTypes, function (postType, name) {
- return {
- kind: 'postType',
- baseURL: '/wp/v2/' + postType.rest_base,
- name: name,
- label: postType.labels.singular_name,
- transientEdits: {
- blocks: true,
- selectionStart: true,
- selectionEnd: true
- },
- mergedEdits: {
- meta: true
- },
- getTitle: function getTitle(record) {
- if (name === 'wp_template_part' || name === 'wp_template') {
- return Object(external_this_lodash_["startCase"])(record.slug);
- }
-
- return Object(external_this_lodash_["get"])(record, ['title', 'rendered'], record.id);
- }
- };
- }));
-
- case 4:
- case "end":
- return _context.stop();
- }
- }
- }, entities_marked);
-}
-/**
- * Returns the list of the taxonomies entities.
- *
- * @return {Promise} Entities promise
- */
-
-
-function loadTaxonomyEntities() {
- var taxonomies;
- return external_this_regeneratorRuntime_default.a.wrap(function loadTaxonomyEntities$(_context2) {
- while (1) {
- switch (_context2.prev = _context2.next) {
- case 0:
- _context2.next = 2;
- return apiFetch({
- path: '/wp/v2/taxonomies?context=edit'
- });
-
- case 2:
- taxonomies = _context2.sent;
- return _context2.abrupt("return", Object(external_this_lodash_["map"])(taxonomies, function (taxonomy, name) {
- return {
- kind: 'taxonomy',
- baseURL: '/wp/v2/' + taxonomy.rest_base,
- name: name,
- label: taxonomy.labels.singular_name
- };
- }));
-
- case 4:
- case "end":
- return _context2.stop();
- }
- }
- }, entities_marked2);
-}
-/**
- * Returns the entity's getter method name given its kind and name.
- *
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {string} prefix Function prefix.
- * @param {boolean} usePlural Whether to use the plural form or not.
- *
- * @return {string} Method name
- */
-
-
-var entities_getMethodName = function getMethodName(kind, name) {
- var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'get';
- var usePlural = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
- var entity = Object(external_this_lodash_["find"])(defaultEntities, {
- kind: kind,
- name: name
- });
- var kindPrefix = kind === 'root' ? '' : Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(kind));
- var nameSuffix = Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(name)) + (usePlural ? 's' : '');
- var suffix = usePlural && entity.plural ? Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(entity.plural)) : nameSuffix;
- return "".concat(prefix).concat(kindPrefix).concat(suffix);
-};
-/**
- * Loads the kind entities into the store.
- *
- * @param {string} kind Kind
- *
- * @return {Array} Entities
- */
-
-function getKindEntities(kind) {
- var entities, kindConfig;
- return external_this_regeneratorRuntime_default.a.wrap(function getKindEntities$(_context3) {
- while (1) {
- switch (_context3.prev = _context3.next) {
- case 0:
- _context3.next = 2;
- return controls_select('getEntitiesByKind', kind);
-
- case 2:
- entities = _context3.sent;
-
- if (!(entities && entities.length !== 0)) {
- _context3.next = 5;
- break;
- }
-
- return _context3.abrupt("return", entities);
-
- case 5:
- kindConfig = Object(external_this_lodash_["find"])(kinds, {
- name: kind
- });
-
- if (kindConfig) {
- _context3.next = 8;
- break;
- }
-
- return _context3.abrupt("return", []);
-
- case 8:
- _context3.next = 10;
- return kindConfig.loadEntities();
-
- case 10:
- entities = _context3.sent;
- _context3.next = 13;
- return addEntities(entities);
-
- case 13:
- return _context3.abrupt("return", entities);
-
- case 14:
- case "end":
- return _context3.stop();
- }
- }
- }, entities_marked3);
-}
-
-// EXTERNAL MODULE: external {"this":["wp","url"]}
-var external_this_wp_url_ = __webpack_require__(31);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js
-/**
- * External dependencies
- */
-
-/**
- * Given a function, returns an enhanced function which caches the result and
- * tracks in WeakMap. The result is only cached if the original function is
- * passed a valid object-like argument (requirement for WeakMap key).
- *
- * @param {Function} fn Original function.
- *
- * @return {Function} Enhanced caching function.
- */
-
-function withWeakMapCache(fn) {
- var cache = new WeakMap();
- return function (key) {
- var value;
-
- if (cache.has(key)) {
- value = cache.get(key);
- } else {
- value = fn(key); // Can reach here if key is not valid for WeakMap, since `has`
- // will return false for invalid key. Since `set` will throw,
- // ensure that key is valid before setting into cache.
-
- if (Object(external_this_lodash_["isObjectLike"])(key)) {
- cache.set(key, value);
- }
- }
-
- return value;
- };
-}
-
-/* harmony default export */ var with_weak_map_cache = (withWeakMapCache);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js
-
-
-/**
- * WordPress dependencies
- */
-
-/**
- * Internal dependencies
- */
-
-
-/**
- * An object of properties describing a specific query.
- *
- * @typedef {Object} WPQueriedDataQueryParts
- *
- * @property {number} page The query page (1-based index, default 1).
- * @property {number} perPage Items per page for query (default 10).
- * @property {string} stableKey An encoded stable string of all non-pagination
- * query parameters.
- */
-
-/**
- * Given a query object, returns an object of parts, including pagination
- * details (`page` and `perPage`, or default values). All other properties are
- * encoded into a stable (idempotent) `stableKey` value.
- *
- * @param {Object} query Optional query object.
- *
- * @return {WPQueriedDataQueryParts} Query parts.
- */
-
-function getQueryParts(query) {
- /**
- * @type {WPQueriedDataQueryParts}
- */
- var parts = {
- stableKey: '',
- page: 1,
- perPage: 10
- }; // Ensure stable key by sorting keys. Also more efficient for iterating.
-
- var keys = Object.keys(query).sort();
-
- for (var i = 0; i < keys.length; i++) {
- var key = keys[i];
- var value = query[key];
-
- switch (key) {
- case 'page':
- parts[key] = Number(value);
- break;
-
- case 'per_page':
- parts.perPage = Number(value);
- break;
-
- default:
- // While it could be any deterministic string, for simplicity's
- // sake mimic querystring encoding for stable key.
- //
- // TODO: For consistency with PHP implementation, addQueryArgs
- // should accept a key value pair, which may optimize its
- // implementation for our use here, vs. iterating an object
- // with only a single key.
- parts.stableKey += (parts.stableKey ? '&' : '') + Object(external_this_wp_url_["addQueryArgs"])('', Object(defineProperty["a" /* default */])({}, key, value)).slice(1);
- }
- }
-
- return parts;
-}
-/* harmony default export */ var get_query_parts = (with_weak_map_cache(getQueryParts));
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js
-
-
-function reducer_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 reducer_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { reducer_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 { reducer_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * External dependencies
- */
-
-/**
- * WordPress dependencies
- */
-
-
-/**
- * Internal dependencies
- */
-
-
-
-
-/**
- * Returns a merged array of item IDs, given details of the received paginated
- * items. The array is sparse-like with `undefined` entries where holes exist.
- *
- * @param {?Array<number>} itemIds Original item IDs (default empty array).
- * @param {number[]} nextItemIds Item IDs to merge.
- * @param {number} page Page of items merged.
- * @param {number} perPage Number of items per page.
- *
- * @return {number[]} Merged array of item IDs.
- */
-
-function getMergedItemIds(itemIds, nextItemIds, page, perPage) {
- var receivedAllIds = page === 1 && perPage === -1;
-
- if (receivedAllIds) {
- return nextItemIds;
- }
-
- var nextItemIdsStartIndex = (page - 1) * perPage; // If later page has already been received, default to the larger known
- // size of the existing array, else calculate as extending the existing.
-
- var size = Math.max(itemIds.length, nextItemIdsStartIndex + nextItemIds.length); // Preallocate array since size is known.
-
- var mergedItemIds = new Array(size);
-
- for (var i = 0; i < size; i++) {
- // Preserve existing item ID except for subset of range of next items.
- var isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIds.length;
- mergedItemIds[i] = isInNextItemsRange ? nextItemIds[i - nextItemIdsStartIndex] : itemIds[i];
- }
-
- return mergedItemIds;
-}
-/**
- * Reducer tracking items state, keyed by ID. Items are assumed to be normal,
- * where identifiers are common across all queries.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Next state.
- */
-
-function reducer_items() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_ITEMS':
- var key = action.key || DEFAULT_ENTITY_KEY;
- return reducer_objectSpread({}, state, {}, action.items.reduce(function (accumulator, value) {
- var itemId = value[key];
- accumulator[itemId] = conservativeMapItem(state[itemId], value);
- return accumulator;
- }, {}));
- }
-
- return state;
-}
-/**
- * Reducer tracking queries state, keyed by stable query key. Each reducer
- * query object includes `itemIds` and `requestingPageByPerPage`.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Next state.
- */
-
-
-var queries = Object(external_this_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
-// an unhandled action.
-if_matching_action(function (action) {
- return 'query' in action;
-}), // Inject query parts into action for use both in `onSubKey` and reducer.
-replace_action(function (action) {
- // `ifMatchingAction` still passes on initialization, where state is
- // undefined and a query is not assigned. Avoid attempting to parse
- // parts. `onSubKey` will omit by lack of `stableKey`.
- if (action.query) {
- return reducer_objectSpread({}, action, {}, get_query_parts(action.query));
- }
-
- return action;
-}), // Queries shape is shared, but keyed by query `stableKey` part. Original
-// reducer tracks only a single query object.
-on_sub_key('stableKey')])(function () {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
- var action = arguments.length > 1 ? arguments[1] : undefined;
- var type = action.type,
- page = action.page,
- perPage = action.perPage,
- _action$key = action.key,
- key = _action$key === void 0 ? DEFAULT_ENTITY_KEY : _action$key;
-
- if (type !== 'RECEIVE_ITEMS') {
- return state;
- }
-
- return getMergedItemIds(state || [], Object(external_this_lodash_["map"])(action.items, key), page, perPage);
-});
-/* harmony default export */ var queried_data_reducer = (Object(external_this_wp_data_["combineReducers"])({
- items: reducer_items,
- queries: queries
-}));
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/reducer.js
-
-
-
-
-function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-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; }
-
-function build_module_reducer_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 build_module_reducer_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_reducer_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 { build_module_reducer_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * External dependencies
- */
-
-/**
- * WordPress dependencies
- */
-
-
-
-/**
- * Internal dependencies
- */
-
-
-
-
-/**
- * Reducer managing terms state. Keyed by taxonomy slug, the value is either
- * undefined (if no request has been made for given taxonomy), null (if a
- * request is in-flight for given taxonomy), or the array of terms for the
- * taxonomy.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function terms() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_TERMS':
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.taxonomy, action.terms));
- }
-
- return state;
-}
-/**
- * Reducer managing authors state. Keyed by id.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function reducer_users() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
- byId: {},
- queries: {}
- };
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_USER_QUERY':
- return {
- byId: build_module_reducer_objectSpread({}, state.byId, {}, Object(external_this_lodash_["keyBy"])(action.users, 'id')),
- queries: build_module_reducer_objectSpread({}, state.queries, Object(defineProperty["a" /* default */])({}, action.queryID, Object(external_this_lodash_["map"])(action.users, function (user) {
- return user.id;
- })))
- };
- }
-
- return state;
-}
-/**
- * Reducer managing current user state.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function reducer_currentUser() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_CURRENT_USER':
- return action.currentUser;
- }
-
- return state;
-}
-/**
- * Reducer managing taxonomies.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function reducer_taxonomies() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_TAXONOMIES':
- return action.taxonomies;
- }
-
- return state;
-}
-/**
- * Reducer managing the current theme.
- *
- * @param {string} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {string} Updated state.
- */
-
-function currentTheme() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_CURRENT_THEME':
- return action.currentTheme.stylesheet;
- }
-
- return state;
-}
-/**
- * Reducer managing installed themes.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function themes() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_CURRENT_THEME':
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.currentTheme.stylesheet, action.currentTheme));
- }
-
- return state;
-}
-/**
- * Reducer managing theme supports data.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function themeSupports() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_THEME_SUPPORTS':
- return build_module_reducer_objectSpread({}, state, {}, action.themeSupports);
- }
-
- return state;
-}
-/**
- * Higher Order Reducer for a given entity config. It supports:
- *
- * - Fetching
- * - Editing
- * - Saving
- *
- * @param {Object} entityConfig Entity config.
- *
- * @return {Function} Reducer.
- */
-
-function reducer_entity(entityConfig) {
- return Object(external_this_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
- // an unhandled action.
- if_matching_action(function (action) {
- return action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind;
- }), // Inject the entity config into the action.
- replace_action(function (action) {
- return build_module_reducer_objectSpread({}, action, {
- key: entityConfig.key || DEFAULT_ENTITY_KEY
- });
- })])(Object(external_this_wp_data_["combineReducers"])({
- queriedData: queried_data_reducer,
- edits: function edits() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_ITEMS':
- var nextState = build_module_reducer_objectSpread({}, state);
-
- var _iterator = _createForOfIteratorHelper(action.items),
- _step;
-
- try {
- var _loop = function _loop() {
- var record = _step.value;
- var recordId = record[action.key];
- var edits = nextState[recordId];
-
- if (!edits) {
- return "continue";
- }
-
- var nextEdits = Object.keys(edits).reduce(function (acc, key) {
- // If the edited value is still different to the persisted value,
- // keep the edited value in edits.
- if ( // Edits are the "raw" attribute values, but records may have
- // objects with more properties, so we use `get` here for the
- // comparison.
- !Object(external_this_lodash_["isEqual"])(edits[key], Object(external_this_lodash_["get"])(record[key], 'raw', record[key]))) {
- acc[key] = edits[key];
- }
-
- return acc;
- }, {});
-
- if (Object.keys(nextEdits).length) {
- nextState[recordId] = nextEdits;
- } else {
- delete nextState[recordId];
- }
- };
-
- for (_iterator.s(); !(_step = _iterator.n()).done;) {
- var _ret = _loop();
-
- if (_ret === "continue") continue;
- }
- } catch (err) {
- _iterator.e(err);
- } finally {
- _iterator.f();
- }
-
- return nextState;
-
- case 'EDIT_ENTITY_RECORD':
- var nextEdits = build_module_reducer_objectSpread({}, state[action.recordId], {}, action.edits);
-
- Object.keys(nextEdits).forEach(function (key) {
- // Delete cleared edits so that the properties
- // are not considered dirty.
- if (nextEdits[key] === undefined) {
- delete nextEdits[key];
- }
- });
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.recordId, nextEdits));
- }
-
- return state;
- },
- saving: function saving() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'SAVE_ENTITY_RECORD_START':
- case 'SAVE_ENTITY_RECORD_FINISH':
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.recordId, {
- pending: action.type === 'SAVE_ENTITY_RECORD_START',
- error: action.error,
- isAutosave: action.isAutosave
- }));
- }
-
- return state;
- }
- }));
-}
-/**
- * Reducer keeping track of the registered entities.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-
-function entitiesConfig() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultEntities;
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'ADD_ENTITIES':
- return [].concat(Object(toConsumableArray["a" /* default */])(state), Object(toConsumableArray["a" /* default */])(action.entities));
- }
-
- return state;
-}
-/**
- * Reducer keeping track of the registered entities config and data.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-var reducer_entities = function entities() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
- var newConfig = entitiesConfig(state.config, action); // Generates a dynamic reducer for the entities
-
- var entitiesDataReducer = state.reducer;
-
- if (!entitiesDataReducer || newConfig !== state.config) {
- var entitiesByKind = Object(external_this_lodash_["groupBy"])(newConfig, 'kind');
- entitiesDataReducer = Object(external_this_wp_data_["combineReducers"])(Object.entries(entitiesByKind).reduce(function (memo, _ref) {
- var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2),
- kind = _ref2[0],
- subEntities = _ref2[1];
-
- var kindReducer = Object(external_this_wp_data_["combineReducers"])(subEntities.reduce(function (kindMemo, entityConfig) {
- return build_module_reducer_objectSpread({}, kindMemo, Object(defineProperty["a" /* default */])({}, entityConfig.name, reducer_entity(entityConfig)));
- }, {}));
- memo[kind] = kindReducer;
- return memo;
- }, {}));
- }
-
- var newData = entitiesDataReducer(state.data, action);
-
- if (newData === state.data && newConfig === state.config && entitiesDataReducer === state.reducer) {
- return state;
- }
-
- return {
- reducer: entitiesDataReducer,
- data: newData,
- config: newConfig
- };
-};
-/**
- * Reducer keeping track of entity edit undo history.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-var UNDO_INITIAL_STATE = [];
-UNDO_INITIAL_STATE.offset = 0;
-var lastEditAction;
-function reducer_undo() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UNDO_INITIAL_STATE;
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'EDIT_ENTITY_RECORD':
- case 'CREATE_UNDO_LEVEL':
- var isCreateUndoLevel = action.type === 'CREATE_UNDO_LEVEL';
- var isUndoOrRedo = !isCreateUndoLevel && (action.meta.isUndo || action.meta.isRedo);
-
- if (isCreateUndoLevel) {
- action = lastEditAction;
- } else if (!isUndoOrRedo) {
- // Don't lose the last edit cache if the new one only has transient edits.
- // Transient edits don't create new levels so updating the cache would make
- // us skip an edit later when creating levels explicitly.
- if (Object.keys(action.edits).some(function (key) {
- return !action.transientEdits[key];
- })) {
- lastEditAction = action;
- } else {
- lastEditAction = build_module_reducer_objectSpread({}, action, {
- edits: build_module_reducer_objectSpread({}, lastEditAction && lastEditAction.edits, {}, action.edits)
- });
- }
- }
-
- var nextState;
-
- if (isUndoOrRedo) {
- nextState = Object(toConsumableArray["a" /* default */])(state);
- nextState.offset = state.offset + (action.meta.isUndo ? -1 : 1);
-
- if (state.flattenedUndo) {
- // The first undo in a sequence of undos might happen while we have
- // flattened undos in state. If this is the case, we want execution
- // to continue as if we were creating an explicit undo level. This
- // will result in an extra undo level being appended with the flattened
- // undo values.
- isCreateUndoLevel = true;
- action = lastEditAction;
- } else {
- return nextState;
- }
- }
-
- if (!action.meta.undo) {
- return state;
- } // Transient edits don't create an undo level, but are
- // reachable in the next meaningful edit to which they
- // are merged. They are defined in the entity's config.
-
-
- if (!isCreateUndoLevel && !Object.keys(action.edits).some(function (key) {
- return !action.transientEdits[key];
- })) {
- nextState = Object(toConsumableArray["a" /* default */])(state);
- nextState.flattenedUndo = build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.edits);
- nextState.offset = state.offset;
- return nextState;
- } // Clear potential redos, because this only supports linear history.
-
-
- nextState = nextState || state.slice(0, state.offset || undefined);
- nextState.offset = nextState.offset || 0;
- nextState.pop();
-
- if (!isCreateUndoLevel) {
- nextState.push({
- kind: action.meta.undo.kind,
- name: action.meta.undo.name,
- recordId: action.meta.undo.recordId,
- edits: build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.meta.undo.edits)
- });
- } // When an edit is a function it's an optimization to avoid running some expensive operation.
- // We can't rely on the function references being the same so we opt out of comparing them here.
-
-
- var comparisonUndoEdits = Object.values(action.meta.undo.edits).filter(function (edit) {
- return typeof edit !== 'function';
- });
- var comparisonEdits = Object.values(action.edits).filter(function (edit) {
- return typeof edit !== 'function';
- });
-
- if (!external_this_wp_isShallowEqual_default()(comparisonUndoEdits, comparisonEdits)) {
- nextState.push({
- kind: action.kind,
- name: action.name,
- recordId: action.recordId,
- edits: isCreateUndoLevel ? build_module_reducer_objectSpread({}, state.flattenedUndo, {}, action.edits) : action.edits
- });
- }
-
- return nextState;
- }
-
- return state;
-}
-/**
- * Reducer managing embed preview data.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function embedPreviews() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_EMBED_PREVIEW':
- var url = action.url,
- preview = action.preview;
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, url, preview));
- }
-
- return state;
-}
-/**
- * State which tracks whether the user can perform an action on a REST
- * resource.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function userPermissions() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_USER_PERMISSION':
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.key, action.isAllowed));
- }
-
- return state;
-}
-/**
- * Reducer returning autosaves keyed by their parent's post id.
- *
- * @param {Object} state Current state.
- * @param {Object} action Dispatched action.
- *
- * @return {Object} Updated state.
- */
-
-function reducer_autosaves() {
- var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
- var action = arguments.length > 1 ? arguments[1] : undefined;
-
- switch (action.type) {
- case 'RECEIVE_AUTOSAVES':
- var postId = action.postId,
- autosavesData = action.autosaves;
- return build_module_reducer_objectSpread({}, state, Object(defineProperty["a" /* default */])({}, postId, autosavesData));
- }
-
- return state;
-}
-/* harmony default export */ var build_module_reducer = (Object(external_this_wp_data_["combineReducers"])({
- terms: terms,
- users: reducer_users,
- currentTheme: currentTheme,
- currentUser: reducer_currentUser,
- taxonomies: reducer_taxonomies,
- themes: themes,
- themeSupports: themeSupports,
- entities: reducer_entities,
- undo: reducer_undo,
- embedPreviews: embedPreviews,
- userPermissions: userPermissions,
- autosaves: reducer_autosaves
-}));
-
-// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
-var rememo = __webpack_require__(42);
-
-// EXTERNAL MODULE: external {"this":["wp","deprecated"]}
-var external_this_wp_deprecated_ = __webpack_require__(37);
-var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
-/**
- * The reducer key used by core data in store registration.
- * This is defined in a separate file to avoid cycle-dependency
- *
- * @type {string}
- */
-var REDUCER_KEY = 'core';
-
-// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
-var equivalent_key_map = __webpack_require__(126);
-var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js
-/**
- * External dependencies
- */
-
-
-/**
- * Internal dependencies
- */
-
-
-/**
- * Cache of state keys to EquivalentKeyMap where the inner map tracks queries
- * to their resulting items set. WeakMap allows garbage collection on expired
- * state references.
- *
- * @type {WeakMap<Object,EquivalentKeyMap>}
- */
-
-var queriedItemsCacheByState = new WeakMap();
-/**
- * Returns items for a given query, or null if the items are not known.
- *
- * @param {Object} state State object.
- * @param {?Object} query Optional query.
- *
- * @return {?Array} Query items.
- */
-
-function getQueriedItemsUncached(state, query) {
- var _getQueryParts = get_query_parts(query),
- stableKey = _getQueryParts.stableKey,
- page = _getQueryParts.page,
- perPage = _getQueryParts.perPage;
-
- if (!state.queries[stableKey]) {
- return null;
- }
-
- var itemIds = state.queries[stableKey];
-
- if (!itemIds) {
- return null;
- }
-
- var startOffset = perPage === -1 ? 0 : (page - 1) * perPage;
- var endOffset = perPage === -1 ? itemIds.length : Math.min(startOffset + perPage, itemIds.length);
- var items = [];
-
- for (var i = startOffset; i < endOffset; i++) {
- var itemId = itemIds[i];
- items.push(state.items[itemId]);
- }
-
- return items;
-}
-/**
- * Returns items for a given query, or null if the items are not known. Caches
- * result both per state (by reference) and per query (by deep equality).
- * The caching approach is intended to be durable to query objects which are
- * deeply but not referentially equal, since otherwise:
- *
- * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )`
- *
- * @param {Object} state State object.
- * @param {?Object} query Optional query.
- *
- * @return {?Array} Query items.
- */
-
-
-var getQueriedItems = Object(rememo["a" /* default */])(function (state) {
- var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
- var queriedItemsCache = queriedItemsCacheByState.get(state);
-
- if (queriedItemsCache) {
- var queriedItems = queriedItemsCache.get(query);
-
- if (queriedItems !== undefined) {
- return queriedItems;
- }
- } else {
- queriedItemsCache = new equivalent_key_map_default.a();
- queriedItemsCacheByState.set(state, queriedItemsCache);
- }
-
- var items = getQueriedItemsUncached(state, query);
- queriedItemsCache.set(query, items);
- return items;
-});
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/selectors.js
-
-
-function selectors_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 selectors_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { selectors_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 { selectors_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * External dependencies
- */
-
-
-/**
- * WordPress dependencies
- */
-
-
-
-/**
- * Internal dependencies
- */
-
-
-
-
-/**
- * Returns true if a request is in progress for embed preview data, or false
- * otherwise.
- *
- * @param {Object} state Data state.
- * @param {string} url URL the preview would be for.
- *
- * @return {boolean} Whether a request is in progress for an embed preview.
- */
-
-var isRequestingEmbedPreview = Object(external_this_wp_data_["createRegistrySelector"])(function (select) {
- return function (state, url) {
- return select('core/data').isResolving(REDUCER_KEY, 'getEmbedPreview', [url]);
- };
-});
-/**
- * Returns all available authors.
- *
- * @param {Object} state Data state.
- *
- * @return {Array} Authors list.
- */
-
-function getAuthors(state) {
- return getUserQueryResults(state, 'authors');
-}
-/**
- * Returns the current user.
- *
- * @param {Object} state Data state.
- *
- * @return {Object} Current user object.
- */
-
-function getCurrentUser(state) {
- return state.currentUser;
-}
-/**
- * Returns all the users returned by a query ID.
- *
- * @param {Object} state Data state.
- * @param {string} queryID Query ID.
- *
- * @return {Array} Users list.
- */
-
-var getUserQueryResults = Object(rememo["a" /* default */])(function (state, queryID) {
- var queryResults = state.users.queries[queryID];
- return Object(external_this_lodash_["map"])(queryResults, function (id) {
- return state.users.byId[id];
- });
-}, function (state, queryID) {
- return [state.users.queries[queryID], state.users.byId];
-});
-/**
- * Returns whether the entities for the give kind are loaded.
- *
- * @param {Object} state Data state.
- * @param {string} kind Entity kind.
- *
- * @return {boolean} Whether the entities are loaded
- */
-
-function getEntitiesByKind(state, kind) {
- return Object(external_this_lodash_["filter"])(state.entities.config, {
- kind: kind
- });
-}
-/**
- * Returns the entity object given its kind and name.
- *
- * @param {Object} state Data state.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- *
- * @return {Object} Entity
- */
-
-function selectors_getEntity(state, kind, name) {
- return Object(external_this_lodash_["find"])(state.entities.config, {
- kind: kind,
- name: name
- });
-}
-/**
- * Returns the Entity's record object by key.
- *
- * @param {Object} state State tree
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} key Record's key
- *
- * @return {Object?} Record.
- */
-
-function getEntityRecord(state, kind, name, key) {
- return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'queriedData', 'items', key]);
-}
-/**
- * Returns the Entity's record object by key. Doesn't trigger a resolver nor requests the entity from the API if the entity record isn't available in the local state.
- *
- * @param {Object} state State tree
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} key Record's key
- *
- * @return {Object?} Record.
- */
-
-function __experimentalGetEntityRecordNoResolver(state, kind, name, key) {
- return getEntityRecord(state, kind, name, key);
-}
-/**
- * Returns the entity's record object by key,
- * with its attributes mapped to their raw values.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} key Record's key.
- *
- * @return {Object?} Object with the entity's raw attributes.
- */
-
-var getRawEntityRecord = Object(rememo["a" /* default */])(function (state, kind, name, key) {
- var record = getEntityRecord(state, kind, name, key);
- return record && Object.keys(record).reduce(function (accumulator, _key) {
- // Because edits are the "raw" attribute values,
- // we return those from record selectors to make rendering,
- // comparisons, and joins with edits easier.
- accumulator[_key] = Object(external_this_lodash_["get"])(record[_key], 'raw', record[_key]);
- return accumulator;
- }, {});
-}, function (state) {
- return [state.entities.data];
-});
-/**
- * Returns the Entity's records.
- *
- * @param {Object} state State tree
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {?Object} query Optional terms query.
- *
- * @return {?Array} Records.
- */
-
-function getEntityRecords(state, kind, name, query) {
- var queriedState = Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'queriedData']);
-
- if (!queriedState) {
- return [];
- }
-
- return getQueriedItems(queriedState, query);
-}
-/**
- * Returns the list of dirty entity records.
- *
- * @param {Object} state State tree.
- *
- * @return {[{ title: string, key: string, name: string, kind: string }]} The list of updated records
- */
-
-var __experimentalGetDirtyEntityRecords = Object(rememo["a" /* default */])(function (state) {
- var data = state.entities.data;
- var dirtyRecords = [];
- Object.keys(data).forEach(function (kind) {
- Object.keys(data[kind]).forEach(function (name) {
- var primaryKeys = Object.keys(data[kind][name].edits).filter(function (primaryKey) {
- return hasEditsForEntityRecord(state, kind, name, primaryKey);
- });
-
- if (primaryKeys.length) {
- var entity = selectors_getEntity(state, kind, name);
- primaryKeys.forEach(function (primaryKey) {
- var entityRecord = getEntityRecord(state, kind, name, primaryKey);
- dirtyRecords.push({
- // We avoid using primaryKey because it's transformed into a string
- // when it's used as an object key.
- key: entityRecord[entity.key || DEFAULT_ENTITY_KEY],
- title: !entity.getTitle ? '' : entity.getTitle(entityRecord),
- name: name,
- kind: kind
- });
- });
- }
- });
- });
- return dirtyRecords;
-}, function (state) {
- return [state.entities.data];
-});
-/**
- * Returns the specified entity record's edits.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {Object?} The entity record's edits.
- */
-
-function getEntityRecordEdits(state, kind, name, recordId) {
- return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'edits', recordId]);
-}
-/**
- * Returns the specified entity record's non transient edits.
- *
- * Transient edits don't create an undo level, and
- * are not considered for change detection.
- * They are defined in the entity's config.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {Object?} The entity record's non transient edits.
- */
-
-var getEntityRecordNonTransientEdits = Object(rememo["a" /* default */])(function (state, kind, name, recordId) {
- var _ref = selectors_getEntity(state, kind, name) || {},
- transientEdits = _ref.transientEdits;
-
- var edits = getEntityRecordEdits(state, kind, name, recordId) || {};
-
- if (!transientEdits) {
- return edits;
- }
-
- return Object.keys(edits).reduce(function (acc, key) {
- if (!transientEdits[key]) {
- acc[key] = edits[key];
- }
-
- return acc;
- }, {});
-}, function (state) {
- return [state.entities.config, state.entities.data];
-});
-/**
- * Returns true if the specified entity record has edits,
- * and false otherwise.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {boolean} Whether the entity record has edits or not.
- */
-
-function hasEditsForEntityRecord(state, kind, name, recordId) {
- return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(getEntityRecordNonTransientEdits(state, kind, name, recordId)).length > 0;
-}
-/**
- * Returns the specified entity record, merged with its edits.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {Object?} The entity record, merged with its edits.
- */
-
-var getEditedEntityRecord = Object(rememo["a" /* default */])(function (state, kind, name, recordId) {
- return selectors_objectSpread({}, getRawEntityRecord(state, kind, name, recordId), {}, getEntityRecordEdits(state, kind, name, recordId));
-}, function (state) {
- return [state.entities.data];
-});
-/**
- * Returns true if the specified entity record is autosaving, and false otherwise.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {boolean} Whether the entity record is autosaving or not.
- */
-
-function isAutosavingEntityRecord(state, kind, name, recordId) {
- var _get = Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId], {}),
- pending = _get.pending,
- isAutosave = _get.isAutosave;
-
- return Boolean(pending && isAutosave);
-}
-/**
- * Returns true if the specified entity record is saving, and false otherwise.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {boolean} Whether the entity record is saving or not.
- */
-
-function isSavingEntityRecord(state, kind, name, recordId) {
- return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'pending'], false);
-}
-/**
- * Returns the specified entity record's last save error.
- *
- * @param {Object} state State tree.
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} recordId Record ID.
- *
- * @return {Object?} The entity record's save error.
- */
-
-function getLastEntitySaveError(state, kind, name, recordId) {
- return Object(external_this_lodash_["get"])(state.entities.data, [kind, name, 'saving', recordId, 'error']);
-}
-/**
- * Returns the current undo offset for the
- * entity records edits history. The offset
- * represents how many items from the end
- * of the history stack we are at. 0 is the
- * last edit, -1 is the second last, and so on.
- *
- * @param {Object} state State tree.
- *
- * @return {number} The current undo offset.
- */
-
-function getCurrentUndoOffset(state) {
- return state.undo.offset;
-}
-/**
- * Returns the previous edit from the current undo offset
- * for the entity records edits history, if any.
- *
- * @param {Object} state State tree.
- *
- * @return {Object?} The edit.
- */
-
-
-function getUndoEdit(state) {
- return state.undo[state.undo.length - 2 + getCurrentUndoOffset(state)];
-}
-/**
- * Returns the next edit from the current undo offset
- * for the entity records edits history, if any.
- *
- * @param {Object} state State tree.
- *
- * @return {Object?} The edit.
- */
-
-function getRedoEdit(state) {
- return state.undo[state.undo.length + getCurrentUndoOffset(state)];
-}
-/**
- * Returns true if there is a previous edit from the current undo offset
- * for the entity records edits history, and false otherwise.
- *
- * @param {Object} state State tree.
- *
- * @return {boolean} Whether there is a previous edit or not.
- */
-
-function hasUndo(state) {
- return Boolean(getUndoEdit(state));
-}
-/**
- * Returns true if there is a next edit from the current undo offset
- * for the entity records edits history, and false otherwise.
- *
- * @param {Object} state State tree.
- *
- * @return {boolean} Whether there is a next edit or not.
- */
-
-function hasRedo(state) {
- return Boolean(getRedoEdit(state));
-}
-/**
- * Return the current theme.
- *
- * @param {Object} state Data state.
- *
- * @return {Object} The current theme.
- */
-
-function getCurrentTheme(state) {
- return state.themes[state.currentTheme];
-}
-/**
- * Return theme supports data in the index.
- *
- * @param {Object} state Data state.
- *
- * @return {*} Index data.
- */
-
-function getThemeSupports(state) {
- return state.themeSupports;
-}
-/**
- * Returns the embed preview for the given URL.
- *
- * @param {Object} state Data state.
- * @param {string} url Embedded URL.
- *
- * @return {*} Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API.
- */
-
-function getEmbedPreview(state, url) {
- return state.embedPreviews[url];
-}
-/**
- * Determines if the returned preview is an oEmbed link fallback.
- *
- * WordPress can be configured to return a simple link to a URL if it is not embeddable.
- * We need to be able to determine if a URL is embeddable or not, based on what we
- * get back from the oEmbed preview API.
- *
- * @param {Object} state Data state.
- * @param {string} url Embedded URL.
- *
- * @return {boolean} Is the preview for the URL an oEmbed link fallback.
- */
-
-function isPreviewEmbedFallback(state, url) {
- var preview = state.embedPreviews[url];
- var oEmbedLinkCheck = '<a href="' + url + '">' + url + '</a>';
-
- if (!preview) {
- return false;
- }
-
- return preview.html === oEmbedLinkCheck;
-}
-/**
- * Returns whether the current user can upload media.
- *
- * Calling this may trigger an OPTIONS request to the REST API via the
- * `canUser()` resolver.
- *
- * https://developer.wordpress.org/rest-api/reference/
- *
- * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of
- * `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`.
- *
- * @param {Object} state Data state.
- *
- * @return {boolean} Whether or not the user can upload media. Defaults to `true` if the OPTIONS
- * request is being made.
- */
-
-function hasUploadPermissions(state) {
- external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", {
- alternative: "select( 'core' ).canUser( 'create', 'media' )"
- });
- return Object(external_this_lodash_["defaultTo"])(canUser(state, 'create', 'media'), true);
-}
-/**
- * Returns whether the current user can perform the given action on the given
- * REST resource.
- *
- * Calling this may trigger an OPTIONS request to the REST API via the
- * `canUser()` resolver.
- *
- * https://developer.wordpress.org/rest-api/reference/
- *
- * @param {Object} state Data state.
- * @param {string} action Action to check. One of: 'create', 'read', 'update', 'delete'.
- * @param {string} resource REST resource to check, e.g. 'media' or 'posts'.
- * @param {string=} id Optional ID of the rest resource to check.
- *
- * @return {boolean|undefined} Whether or not the user can perform the action,
- * or `undefined` if the OPTIONS request is still being made.
- */
-
-function canUser(state, action, resource, id) {
- var key = Object(external_this_lodash_["compact"])([action, resource, id]).join('/');
- return Object(external_this_lodash_["get"])(state, ['userPermissions', key]);
-}
-/**
- * Returns the latest autosaves for the post.
- *
- * May return multiple autosaves since the backend stores one autosave per
- * author for each post.
- *
- * @param {Object} state State tree.
- * @param {string} postType The type of the parent post.
- * @param {number} postId The id of the parent post.
- *
- * @return {?Array} An array of autosaves for the post, or undefined if there is none.
- */
-
-function getAutosaves(state, postType, postId) {
- return state.autosaves[postId];
-}
-/**
- * Returns the autosave for the post and author.
- *
- * @param {Object} state State tree.
- * @param {string} postType The type of the parent post.
- * @param {number} postId The id of the parent post.
- * @param {number} authorId The id of the author.
- *
- * @return {?Object} The autosave for the post and author.
- */
-
-function getAutosave(state, postType, postId, authorId) {
- if (authorId === undefined) {
- return;
- }
-
- var autosaves = state.autosaves[postId];
- return Object(external_this_lodash_["find"])(autosaves, {
- author: authorId
- });
-}
-/**
- * Returns true if the REST request for autosaves has completed.
- *
- * @param {Object} state State tree.
- * @param {string} postType The type of the parent post.
- * @param {number} postId The id of the parent post.
- *
- * @return {boolean} True if the REST request was completed. False otherwise.
- */
-
-var hasFetchedAutosaves = Object(external_this_wp_data_["createRegistrySelector"])(function (select) {
- return function (state, postType, postId) {
- return select(REDUCER_KEY).hasFinishedResolution('getAutosaves', [postType, postId]);
- };
-});
-/**
- * Returns a new reference when edited values have changed. This is useful in
- * inferring where an edit has been made between states by comparison of the
- * return values using strict equality.
- *
- * @example
- *
- * ```
- * const hasEditOccurred = (
- * getReferenceByDistinctEdits( beforeState ) !==
- * getReferenceByDistinctEdits( afterState )
- * );
- * ```
- *
- * @param {Object} state Editor state.
- *
- * @return {*} A value whose reference will change only when an edit occurs.
- */
-
-var getReferenceByDistinctEdits = Object(rememo["a" /* default */])(function () {
- return [];
-}, function (state) {
- return [state.undo.length, state.undo.offset];
-});
-
-// EXTERNAL MODULE: external {"this":["wp","dataControls"]}
-var external_this_wp_dataControls_ = __webpack_require__(36);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-not-resolved.js
-
-
-/**
- * WordPress dependencies
- */
-
-/**
- * Higher-order function which invokes the given resolver only if it has not
- * already been resolved with the arguments passed to the enhanced function.
- *
- * This only considers resolution state, and notably does not support resolver
- * custom `isFulfilled` behavior.
- *
- * @param {Function} resolver Original resolver.
- * @param {string} selectorName Selector name associated with resolver.
- *
- * @return {Function} Enhanced resolver.
- */
-
-var if_not_resolved_ifNotResolved = function ifNotResolved(resolver, selectorName) {
- return (
- /*#__PURE__*/
-
- /**
- * @param {...any} args Original resolver arguments.
- */
- external_this_regeneratorRuntime_default.a.mark(function resolveIfNotResolved() {
- var _len,
- args,
- _key,
- hasStartedResolution,
- _args = arguments;
-
- return external_this_regeneratorRuntime_default.a.wrap(function resolveIfNotResolved$(_context) {
- while (1) {
- switch (_context.prev = _context.next) {
- case 0:
- for (_len = _args.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
- args[_key] = _args[_key];
- }
-
- _context.next = 3;
- return Object(external_this_wp_dataControls_["select"])('core', 'hasStartedResolution', selectorName, args);
-
- case 3:
- hasStartedResolution = _context.sent;
-
- if (hasStartedResolution) {
- _context.next = 6;
- break;
- }
-
- return _context.delegateYield(resolver.apply(void 0, args), "t0", 6);
-
- case 6:
- case "end":
- return _context.stop();
- }
- }
- }, resolveIfNotResolved);
- })
- );
-};
-
-/* harmony default export */ var if_not_resolved = (if_not_resolved_ifNotResolved);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/resolvers.js
-
-
-
-function resolvers_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 resolvers_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { resolvers_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 { resolvers_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-var resolvers_marked = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAuthors),
- resolvers_marked2 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getCurrentUser),
- resolvers_marked3 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEntityRecord),
- resolvers_marked4 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEntityRecords),
- resolvers_marked5 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getCurrentTheme),
- _marked6 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getThemeSupports),
- _marked7 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getEmbedPreview),
- _marked8 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_hasUploadPermissions),
- _marked9 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_canUser),
- _marked10 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAutosaves),
- _marked11 = /*#__PURE__*/external_this_regeneratorRuntime_default.a.mark(resolvers_getAutosave);
-
-/**
- * External dependencies
- */
-
-/**
- * WordPress dependencies
- */
-
-
-
-/**
- * Internal dependencies
- */
-
-
-
-
-
-/**
- * Requests authors from the REST API.
- */
-
-function resolvers_getAuthors() {
- var users;
- return external_this_regeneratorRuntime_default.a.wrap(function getAuthors$(_context) {
- while (1) {
- switch (_context.prev = _context.next) {
- case 0:
- _context.next = 2;
- return apiFetch({
- path: '/wp/v2/users/?who=authors&per_page=-1'
- });
-
- case 2:
- users = _context.sent;
- _context.next = 5;
- return receiveUserQuery('authors', users);
-
- case 5:
- case "end":
- return _context.stop();
- }
- }
- }, resolvers_marked);
-}
-/**
- * Requests the current user from the REST API.
- */
-
-function resolvers_getCurrentUser() {
- var currentUser;
- return external_this_regeneratorRuntime_default.a.wrap(function getCurrentUser$(_context2) {
- while (1) {
- switch (_context2.prev = _context2.next) {
- case 0:
- _context2.next = 2;
- return apiFetch({
- path: '/wp/v2/users/me'
- });
-
- case 2:
- currentUser = _context2.sent;
- _context2.next = 5;
- return receiveCurrentUser(currentUser);
-
- case 5:
- case "end":
- return _context2.stop();
- }
- }
- }, resolvers_marked2);
-}
-/**
- * Requests an entity's record from the REST API.
- *
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {number} key Record's key
- */
-
-function resolvers_getEntityRecord(kind, name) {
- var key,
- entities,
- entity,
- record,
- _args3 = arguments;
- return external_this_regeneratorRuntime_default.a.wrap(function getEntityRecord$(_context3) {
- while (1) {
- switch (_context3.prev = _context3.next) {
- case 0:
- key = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : '';
- _context3.next = 3;
- return getKindEntities(kind);
-
- case 3:
- entities = _context3.sent;
- entity = Object(external_this_lodash_["find"])(entities, {
- kind: kind,
- name: name
- });
-
- if (entity) {
- _context3.next = 7;
- break;
- }
-
- return _context3.abrupt("return");
-
- case 7:
- _context3.next = 9;
- return apiFetch({
- path: "".concat(entity.baseURL, "/").concat(key, "?context=edit")
- });
-
- case 9:
- record = _context3.sent;
- _context3.next = 12;
- return receiveEntityRecords(kind, name, record);
-
- case 12:
- case "end":
- return _context3.stop();
- }
- }
- }, resolvers_marked3);
-}
-/**
- * Requests an entity's record from the REST API.
- */
-
-var resolvers_getRawEntityRecord = if_not_resolved(resolvers_getEntityRecord, 'getEntityRecord');
-/**
- * Requests an entity's record from the REST API.
- */
-
-var resolvers_getEditedEntityRecord = if_not_resolved(resolvers_getRawEntityRecord, 'getRawEntityRecord');
-/**
- * Requests the entity's records from the REST API.
- *
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
- * @param {Object?} query Query Object.
- */
-
-function resolvers_getEntityRecords(kind, name) {
- var query,
- entities,
- entity,
- path,
- records,
- _args4 = arguments;
- return external_this_regeneratorRuntime_default.a.wrap(function getEntityRecords$(_context4) {
- while (1) {
- switch (_context4.prev = _context4.next) {
- case 0:
- query = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
- _context4.next = 3;
- return getKindEntities(kind);
-
- case 3:
- entities = _context4.sent;
- entity = Object(external_this_lodash_["find"])(entities, {
- kind: kind,
- name: name
- });
-
- if (entity) {
- _context4.next = 7;
- break;
- }
-
- return _context4.abrupt("return");
-
- case 7:
- path = Object(external_this_wp_url_["addQueryArgs"])(entity.baseURL, resolvers_objectSpread({}, query, {
- context: 'edit'
- }));
- _context4.next = 10;
- return apiFetch({
- path: path
- });
-
- case 10:
- records = _context4.sent;
- _context4.next = 13;
- return receiveEntityRecords(kind, name, Object.values(records), query);
-
- case 13:
- case "end":
- return _context4.stop();
- }
- }
- }, resolvers_marked4);
-}
-
-resolvers_getEntityRecords.shouldInvalidate = function (action, kind, name) {
- return action.type === 'RECEIVE_ITEMS' && action.invalidateCache && kind === action.kind && name === action.name;
-};
-/**
- * Requests the current theme.
- */
-
-
-function resolvers_getCurrentTheme() {
- var activeThemes;
- return external_this_regeneratorRuntime_default.a.wrap(function getCurrentTheme$(_context5) {
- while (1) {
- switch (_context5.prev = _context5.next) {
- case 0:
- _context5.next = 2;
- return apiFetch({
- path: '/wp/v2/themes?status=active'
- });
-
- case 2:
- activeThemes = _context5.sent;
- _context5.next = 5;
- return receiveCurrentTheme(activeThemes[0]);
-
- case 5:
- case "end":
- return _context5.stop();
- }
- }
- }, resolvers_marked5);
-}
-/**
- * Requests theme supports data from the index.
- */
-
-function resolvers_getThemeSupports() {
- var activeThemes;
- return external_this_regeneratorRuntime_default.a.wrap(function getThemeSupports$(_context6) {
- while (1) {
- switch (_context6.prev = _context6.next) {
- case 0:
- _context6.next = 2;
- return apiFetch({
- path: '/wp/v2/themes?status=active'
- });
-
- case 2:
- activeThemes = _context6.sent;
- _context6.next = 5;
- return receiveThemeSupports(activeThemes[0].theme_supports);
-
- case 5:
- case "end":
- return _context6.stop();
- }
- }
- }, _marked6);
-}
-/**
- * Requests a preview from the from the Embed API.
- *
- * @param {string} url URL to get the preview for.
- */
-
-function resolvers_getEmbedPreview(url) {
- var embedProxyResponse;
- return external_this_regeneratorRuntime_default.a.wrap(function getEmbedPreview$(_context7) {
- while (1) {
- switch (_context7.prev = _context7.next) {
- case 0:
- _context7.prev = 0;
- _context7.next = 3;
- return apiFetch({
- path: Object(external_this_wp_url_["addQueryArgs"])('/oembed/1.0/proxy', {
- url: url
- })
- });
-
- case 3:
- embedProxyResponse = _context7.sent;
- _context7.next = 6;
- return receiveEmbedPreview(url, embedProxyResponse);
-
- case 6:
- _context7.next = 12;
- break;
-
- case 8:
- _context7.prev = 8;
- _context7.t0 = _context7["catch"](0);
- _context7.next = 12;
- return receiveEmbedPreview(url, false);
-
- case 12:
- case "end":
- return _context7.stop();
- }
- }
- }, _marked7, null, [[0, 8]]);
-}
-/**
- * Requests Upload Permissions from the REST API.
- *
- * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of
- * `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`.
- */
-
-function resolvers_hasUploadPermissions() {
- return external_this_regeneratorRuntime_default.a.wrap(function hasUploadPermissions$(_context8) {
- while (1) {
- switch (_context8.prev = _context8.next) {
- case 0:
- external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", {
- alternative: "select( 'core' ).canUser( 'create', 'media' )"
- });
- return _context8.delegateYield(resolvers_canUser('create', 'media'), "t0", 2);
-
- case 2:
- case "end":
- return _context8.stop();
- }
- }
- }, _marked8);
-}
-/**
- * Checks whether the current user can perform the given action on the given
- * REST resource.
- *
- * @param {string} action Action to check. One of: 'create', 'read', 'update',
- * 'delete'.
- * @param {string} resource REST resource to check, e.g. 'media' or 'posts'.
- * @param {?string} id ID of the rest resource to check.
- */
-
-function resolvers_canUser(action, resource, id) {
- var methods, method, path, response, allowHeader, key, isAllowed;
- return external_this_regeneratorRuntime_default.a.wrap(function canUser$(_context9) {
- while (1) {
- switch (_context9.prev = _context9.next) {
- case 0:
- methods = {
- create: 'POST',
- read: 'GET',
- update: 'PUT',
- delete: 'DELETE'
- };
- method = methods[action];
-
- if (method) {
- _context9.next = 4;
- break;
- }
-
- throw new Error("'".concat(action, "' is not a valid action."));
-
- case 4:
- path = id ? "/wp/v2/".concat(resource, "/").concat(id) : "/wp/v2/".concat(resource);
- _context9.prev = 5;
- _context9.next = 8;
- return apiFetch({
- path: path,
- // Ideally this would always be an OPTIONS request, but unfortunately there's
- // a bug in the REST API which causes the Allow header to not be sent on
- // OPTIONS requests to /posts/:id routes.
- // https://core.trac.wordpress.org/ticket/45753
- method: id ? 'GET' : 'OPTIONS',
- parse: false
- });
-
- case 8:
- response = _context9.sent;
- _context9.next = 14;
- break;
-
- case 11:
- _context9.prev = 11;
- _context9.t0 = _context9["catch"](5);
- return _context9.abrupt("return");
-
- case 14:
- if (Object(external_this_lodash_["hasIn"])(response, ['headers', 'get'])) {
- // If the request is fetched using the fetch api, the header can be
- // retrieved using the 'get' method.
- allowHeader = response.headers.get('allow');
- } else {
- // If the request was preloaded server-side and is returned by the
- // preloading middleware, the header will be a simple property.
- allowHeader = Object(external_this_lodash_["get"])(response, ['headers', 'Allow'], '');
- }
-
- key = Object(external_this_lodash_["compact"])([action, resource, id]).join('/');
- isAllowed = Object(external_this_lodash_["includes"])(allowHeader, method);
- _context9.next = 19;
- return receiveUserPermission(key, isAllowed);
-
- case 19:
- case "end":
- return _context9.stop();
- }
- }
- }, _marked9, null, [[5, 11]]);
-}
-/**
- * Request autosave data from the REST API.
- *
- * @param {string} postType The type of the parent post.
- * @param {number} postId The id of the parent post.
- */
-
-function resolvers_getAutosaves(postType, postId) {
- var _yield$resolveSelect, restBase, autosaves;
-
- return external_this_regeneratorRuntime_default.a.wrap(function getAutosaves$(_context10) {
- while (1) {
- switch (_context10.prev = _context10.next) {
- case 0:
- _context10.next = 2;
- return resolveSelect('getPostType', postType);
-
- case 2:
- _yield$resolveSelect = _context10.sent;
- restBase = _yield$resolveSelect.rest_base;
- _context10.next = 6;
- return apiFetch({
- path: "/wp/v2/".concat(restBase, "/").concat(postId, "/autosaves?context=edit")
- });
-
- case 6:
- autosaves = _context10.sent;
-
- if (!(autosaves && autosaves.length)) {
- _context10.next = 10;
- break;
- }
-
- _context10.next = 10;
- return receiveAutosaves(postId, autosaves);
-
- case 10:
- case "end":
- return _context10.stop();
- }
- }
- }, _marked10);
-}
-/**
- * Request autosave data from the REST API.
- *
- * This resolver exists to ensure the underlying autosaves are fetched via
- * `getAutosaves` when a call to the `getAutosave` selector is made.
- *
- * @param {string} postType The type of the parent post.
- * @param {number} postId The id of the parent post.
- */
-
-function resolvers_getAutosave(postType, postId) {
- return external_this_regeneratorRuntime_default.a.wrap(function getAutosave$(_context11) {
- while (1) {
- switch (_context11.prev = _context11.next) {
- case 0:
- _context11.next = 2;
- return resolveSelect('getAutosaves', postType, postId);
-
- case 2:
- case "end":
- return _context11.stop();
- }
- }
- }, _marked11);
-}
-
-// EXTERNAL MODULE: external {"this":["wp","element"]}
-var external_this_wp_element_ = __webpack_require__(0);
-
-// EXTERNAL MODULE: external {"this":["wp","blocks"]}
-var external_this_wp_blocks_ = __webpack_require__(10);
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entity-provider.js
-
-
-
-
-function entity_provider_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 entity_provider_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { entity_provider_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 { entity_provider_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * WordPress dependencies
- */
-
-
-
-/**
- * Internal dependencies
- */
-
-
-
-var entity_provider_entities = entity_provider_objectSpread({}, defaultEntities.reduce(function (acc, entity) {
- if (!acc[entity.kind]) {
- acc[entity.kind] = {};
- }
-
- acc[entity.kind][entity.name] = {
- context: Object(external_this_wp_element_["createContext"])()
- };
- return acc;
-}, {}), {}, kinds.reduce(function (acc, kind) {
- acc[kind.name] = {};
- return acc;
-}, {}));
-
-var entity_provider_getEntity = function getEntity(kind, type) {
- if (!entity_provider_entities[kind]) {
- throw new Error("Missing entity config for kind: ".concat(kind, "."));
- }
-
- if (!entity_provider_entities[kind][type]) {
- entity_provider_entities[kind][type] = {
- context: Object(external_this_wp_element_["createContext"])()
- };
- }
-
- return entity_provider_entities[kind][type];
-};
-/**
- * Context provider component for providing
- * an entity for a specific entity type.
- *
- * @param {Object} props The component's props.
- * @param {string} props.kind The entity kind.
- * @param {string} props.type The entity type.
- * @param {number} props.id The entity ID.
- * @param {*} props.children The children to wrap.
- *
- * @return {Object} The provided children, wrapped with
- * the entity's context provider.
- */
-
-
-function EntityProvider(_ref) {
- var kind = _ref.kind,
- type = _ref.type,
- id = _ref.id,
- children = _ref.children;
- var Provider = entity_provider_getEntity(kind, type).context.Provider;
- return Object(external_this_wp_element_["createElement"])(Provider, {
- value: id
- }, children);
-}
-/**
- * Hook that returns the ID for the nearest
- * provided entity of the specified type.
- *
- * @param {string} kind The entity kind.
- * @param {string} type The entity type.
- */
-
-function useEntityId(kind, type) {
- return Object(external_this_wp_element_["useContext"])(entity_provider_getEntity(kind, type).context);
-}
-/**
- * Hook that returns the value and a setter for the
- * specified property of the nearest provided
- * entity of the specified type.
- *
- * @param {string} kind The entity kind.
- * @param {string} type The entity type.
- * @param {string} prop The property name.
- * @param {string} [_id] An entity ID to use instead of the context-provided one.
- *
- * @return {[*, Function]} A tuple where the first item is the
- * property value and the second is the
- * setter.
- */
-
-function useEntityProp(kind, type, prop, _id) {
- var providerId = useEntityId(kind, type);
- var id = _id !== null && _id !== void 0 ? _id : providerId;
-
- var _useSelect = Object(external_this_wp_data_["useSelect"])(function (select) {
- var _select = select('core'),
- getEntityRecord = _select.getEntityRecord,
- getEditedEntityRecord = _select.getEditedEntityRecord;
-
- var entity = getEntityRecord(kind, type, id); // Trigger resolver.
-
- var editedEntity = getEditedEntityRecord(kind, type, id);
- return entity && editedEntity ? {
- value: editedEntity[prop],
- fullValue: entity[prop]
- } : {};
- }, [kind, type, id, prop]),
- value = _useSelect.value,
- fullValue = _useSelect.fullValue;
-
- var _useDispatch = Object(external_this_wp_data_["useDispatch"])('core'),
- editEntityRecord = _useDispatch.editEntityRecord;
-
- var setValue = Object(external_this_wp_element_["useCallback"])(function (newValue) {
- editEntityRecord(kind, type, id, Object(defineProperty["a" /* default */])({}, prop, newValue));
- }, [kind, type, id, prop]);
- return [value, setValue, fullValue];
-}
-/**
- * Hook that returns block content getters and setters for
- * the nearest provided entity of the specified type.
- *
- * The return value has the shape `[ blocks, onInput, onChange ]`.
- * `onInput` is for block changes that don't create undo levels
- * or dirty the post, non-persistent changes, and `onChange` is for
- * peristent changes. They map directly to the props of a
- * `BlockEditorProvider` and are intended to be used with it,
- * or similar components or hooks.
- *
- * @param {string} kind The entity kind.
- * @param {string} type The entity type.
- * @param {Object} options
- * @param {Object} [options.initialEdits] Initial edits object for the entity record.
- * @param {string} [options.blocksProp='blocks'] The name of the entity prop that holds the blocks array.
- * @param {string} [options.contentProp='content'] The name of the entity prop that holds the serialized blocks.
- * @param {string} [options.id] An entity ID to use instead of the context-provided one.
- *
- * @return {[WPBlock[], Function, Function]} The block array and setters.
- */
-
-function useEntityBlockEditor(kind, type) {
- var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
- initialEdits = _ref2.initialEdits,
- _ref2$blocksProp = _ref2.blocksProp,
- blocksProp = _ref2$blocksProp === void 0 ? 'blocks' : _ref2$blocksProp,
- _ref2$contentProp = _ref2.contentProp,
- contentProp = _ref2$contentProp === void 0 ? 'content' : _ref2$contentProp,
- _id = _ref2.id;
-
- var providerId = useEntityId(kind, type);
- var id = _id !== null && _id !== void 0 ? _id : providerId;
-
- var _useEntityProp = useEntityProp(kind, type, contentProp, id),
- _useEntityProp2 = Object(slicedToArray["a" /* default */])(_useEntityProp, 2),
- content = _useEntityProp2[0],
- setContent = _useEntityProp2[1];
-
- var _useDispatch2 = Object(external_this_wp_data_["useDispatch"])('core'),
- editEntityRecord = _useDispatch2.editEntityRecord;
-
- Object(external_this_wp_element_["useEffect"])(function () {
- if (initialEdits) {
- editEntityRecord(kind, type, id, initialEdits, {
- undoIgnore: true
- });
- }
- }, [id]);
- var initialBlocks = Object(external_this_wp_element_["useMemo"])(function () {
- // Guard against other instances that might have
- // set content to a function already.
- if (content && typeof content !== 'function') {
- var parsedContent = Object(external_this_wp_blocks_["parse"])(content);
- return parsedContent.length ? parsedContent : [];
- }
-
- return [];
- }, [content]);
-
- var _useEntityProp3 = useEntityProp(kind, type, blocksProp, id),
- _useEntityProp4 = Object(slicedToArray["a" /* default */])(_useEntityProp3, 2),
- _useEntityProp4$ = _useEntityProp4[0],
- blocks = _useEntityProp4$ === void 0 ? initialBlocks : _useEntityProp4$,
- onInput = _useEntityProp4[1];
-
- var onChange = Object(external_this_wp_element_["useCallback"])(function (nextBlocks) {
- onInput(nextBlocks); // Use a function edit to avoid serializing often.
-
- setContent(function (_ref3) {
- var blocksToSerialize = _ref3.blocks;
- return Object(external_this_wp_blocks_["serialize"])(blocksToSerialize);
- });
- }, [onInput, setContent]);
- return [blocks, onInput, onChange];
-}
-
-// CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/index.js
-
-
-function build_module_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 build_module_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { build_module_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 { build_module_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-/**
- * WordPress dependencies
- */
-
-/**
- * Internal dependencies
- */
-
-
-
-
-
-
-
- // The entity selectors/resolvers and actions are shortcuts to their generic equivalents
-// (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecordss)
-// Instead of getEntityRecord, the consumer could use more user-frieldly named selector: getPostType, getTaxonomy...
-// The "kind" and the "name" of the entity are combined to generate these shortcuts.
-
-var entitySelectors = defaultEntities.reduce(function (result, entity) {
- var kind = entity.kind,
- name = entity.name;
-
- result[entities_getMethodName(kind, name)] = function (state, key) {
- return getEntityRecord(state, kind, name, key);
- };
-
- result[entities_getMethodName(kind, name, 'get', true)] = function (state) {
- for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
- args[_key - 1] = arguments[_key];
- }
-
- return getEntityRecords.apply(build_module_selectors_namespaceObject, [state, kind, name].concat(args));
- };
-
- return result;
-}, {});
-var entityResolvers = defaultEntities.reduce(function (result, entity) {
- var kind = entity.kind,
- name = entity.name;
-
- result[entities_getMethodName(kind, name)] = function (key) {
- return resolvers_getEntityRecord(kind, name, key);
- };
-
- var pluralMethodName = entities_getMethodName(kind, name, 'get', true);
-
- result[pluralMethodName] = function () {
- for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
- args[_key2] = arguments[_key2];
- }
-
- return resolvers_getEntityRecords.apply(resolvers_namespaceObject, [kind, name].concat(args));
- };
-
- result[pluralMethodName].shouldInvalidate = function (action) {
- var _resolvers$getEntityR;
-
- for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
- args[_key3 - 1] = arguments[_key3];
- }
-
- return (_resolvers$getEntityR = resolvers_getEntityRecords).shouldInvalidate.apply(_resolvers$getEntityR, [action, kind, name].concat(args));
- };
-
- return result;
-}, {});
-var entityActions = defaultEntities.reduce(function (result, entity) {
- var kind = entity.kind,
- name = entity.name;
-
- result[entities_getMethodName(kind, name, 'save')] = function (key) {
- return saveEntityRecord(kind, name, key);
- };
-
- return result;
-}, {});
-Object(external_this_wp_data_["registerStore"])(REDUCER_KEY, {
- reducer: build_module_reducer,
- controls: build_module_controls,
- actions: build_module_objectSpread({}, build_module_actions_namespaceObject, {}, entityActions),
- selectors: build_module_objectSpread({}, build_module_selectors_namespaceObject, {}, entitySelectors),
- resolvers: build_module_objectSpread({}, resolvers_namespaceObject, {}, entityResolvers)
-});
-
-
-
+/***/ "rl8x":
+/***/ (function(module, exports) {
+
+(function() { module.exports = window["wp"]["isShallowEqual"]; }());
/***/ }),
-/***/ 45:
+/***/ "rmEH":
/***/ (function(module, exports) {
-(function() { module.exports = this["wp"]["apiFetch"]; }());
+(function() { module.exports = window["wp"]["htmlEntities"]; }());
/***/ }),
-/***/ 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;
-}
-
-/***/ }),
-
-/***/ 64:
+/***/ "ywyh":
/***/ (function(module, exports) {
-(function() { module.exports = this["wp"]["isShallowEqual"]; }());
+(function() { module.exports = window["wp"]["apiFetch"]; }());
/***/ })