summaryrefslogtreecommitdiffstats
path: root/wp-includes/js/dist/edit-widgets.js
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 07:56:49 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 07:56:49 +0000
commita415c29efee45520ae252d2aa28f1083a521cd7b (patch)
treef4ade4b6668ecc0765de7e1424f7c1427ad433ff /wp-includes/js/dist/edit-widgets.js
parentInitial commit. (diff)
downloadwordpress-a415c29efee45520ae252d2aa28f1083a521cd7b.tar.xz
wordpress-a415c29efee45520ae252d2aa28f1083a521cd7b.zip
Adding upstream version 6.4.3+dfsg1.upstream/6.4.3+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'wp-includes/js/dist/edit-widgets.js')
-rw-r--r--wp-includes/js/dist/edit-widgets.js4671
1 files changed, 4671 insertions, 0 deletions
diff --git a/wp-includes/js/dist/edit-widgets.js b/wp-includes/js/dist/edit-widgets.js
new file mode 100644
index 0000000..67132c2
--- /dev/null
+++ b/wp-includes/js/dist/edit-widgets.js
@@ -0,0 +1,4671 @@
+/******/ (function() { // webpackBootstrap
+/******/ var __webpack_modules__ = ({
+
+/***/ 4403:
+/***/ (function(module, exports) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
+ Copyright (c) 2018 Jed Watson.
+ Licensed under the MIT License (MIT), see
+ http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+ 'use strict';
+
+ var hasOwn = {}.hasOwnProperty;
+ var nativeCodeString = '[native code]';
+
+ function classNames() {
+ var classes = [];
+
+ for (var i = 0; i < arguments.length; i++) {
+ var arg = arguments[i];
+ if (!arg) continue;
+
+ var argType = typeof arg;
+
+ if (argType === 'string' || argType === 'number') {
+ classes.push(arg);
+ } else if (Array.isArray(arg)) {
+ if (arg.length) {
+ var inner = classNames.apply(null, arg);
+ if (inner) {
+ classes.push(inner);
+ }
+ }
+ } else if (argType === 'object') {
+ if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+ classes.push(arg.toString());
+ continue;
+ }
+
+ for (var key in arg) {
+ if (hasOwn.call(arg, key) && arg[key]) {
+ classes.push(key);
+ }
+ }
+ }
+ }
+
+ return classes.join(' ');
+ }
+
+ if ( true && module.exports) {
+ classNames.default = classNames;
+ module.exports = classNames;
+ } else if (true) {
+ // register as 'classnames', consistent with npm package name
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+ return classNames;
+ }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else {}
+}());
+
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ var cachedModule = __webpack_module_cache__[moduleId];
+/******/ if (cachedModule !== undefined) {
+/******/ return cachedModule.exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ // no module.id needed
+/******/ // no module.loaded needed
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ !function() {
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function() { return module['default']; } :
+/******/ function() { return module; };
+/******/ __webpack_require__.d(getter, { a: getter });
+/******/ return getter;
+/******/ };
+/******/ }();
+/******/
+/******/ /* webpack/runtime/define property getters */
+/******/ !function() {
+/******/ // define getter functions for harmony exports
+/******/ __webpack_require__.d = function(exports, definition) {
+/******/ for(var key in definition) {
+/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ }
+/******/ }
+/******/ };
+/******/ }();
+/******/
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ !function() {
+/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ }();
+/******/
+/******/ /* webpack/runtime/make namespace object */
+/******/ !function() {
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/ }();
+/******/
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+!function() {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ initialize: function() { return /* binding */ initialize; },
+ initializeEditor: function() { return /* binding */ initializeEditor; },
+ reinitializeEditor: function() { return /* binding */ reinitializeEditor; },
+ store: function() { return /* reexport */ store_store; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/actions.js
+var actions_namespaceObject = {};
+__webpack_require__.r(actions_namespaceObject);
+__webpack_require__.d(actions_namespaceObject, {
+ closeModal: function() { return closeModal; },
+ disableComplementaryArea: function() { return disableComplementaryArea; },
+ enableComplementaryArea: function() { return enableComplementaryArea; },
+ openModal: function() { return openModal; },
+ pinItem: function() { return pinItem; },
+ setDefaultComplementaryArea: function() { return setDefaultComplementaryArea; },
+ setFeatureDefaults: function() { return setFeatureDefaults; },
+ setFeatureValue: function() { return setFeatureValue; },
+ toggleFeature: function() { return toggleFeature; },
+ unpinItem: function() { return unpinItem; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/selectors.js
+var selectors_namespaceObject = {};
+__webpack_require__.r(selectors_namespaceObject);
+__webpack_require__.d(selectors_namespaceObject, {
+ getActiveComplementaryArea: function() { return getActiveComplementaryArea; },
+ isComplementaryAreaLoading: function() { return isComplementaryAreaLoading; },
+ isFeatureActive: function() { return isFeatureActive; },
+ isItemPinned: function() { return isItemPinned; },
+ isModalActive: function() { return isModalActive; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-widgets/build-module/store/actions.js
+var store_actions_namespaceObject = {};
+__webpack_require__.r(store_actions_namespaceObject);
+__webpack_require__.d(store_actions_namespaceObject, {
+ closeGeneralSidebar: function() { return closeGeneralSidebar; },
+ moveBlockToWidgetArea: function() { return moveBlockToWidgetArea; },
+ persistStubPost: function() { return persistStubPost; },
+ saveEditedWidgetAreas: function() { return saveEditedWidgetAreas; },
+ saveWidgetArea: function() { return saveWidgetArea; },
+ saveWidgetAreas: function() { return saveWidgetAreas; },
+ setIsInserterOpened: function() { return setIsInserterOpened; },
+ setIsListViewOpened: function() { return setIsListViewOpened; },
+ setIsWidgetAreaOpen: function() { return setIsWidgetAreaOpen; },
+ setWidgetAreasOpenState: function() { return setWidgetAreasOpenState; },
+ setWidgetIdForClientId: function() { return setWidgetIdForClientId; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-widgets/build-module/store/resolvers.js
+var resolvers_namespaceObject = {};
+__webpack_require__.r(resolvers_namespaceObject);
+__webpack_require__.d(resolvers_namespaceObject, {
+ getWidgetAreas: function() { return getWidgetAreas; },
+ getWidgets: function() { return getWidgets; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-widgets/build-module/store/selectors.js
+var store_selectors_namespaceObject = {};
+__webpack_require__.r(store_selectors_namespaceObject);
+__webpack_require__.d(store_selectors_namespaceObject, {
+ __experimentalGetInsertionPoint: function() { return __experimentalGetInsertionPoint; },
+ canInsertBlockInWidgetArea: function() { return canInsertBlockInWidgetArea; },
+ getEditedWidgetAreas: function() { return getEditedWidgetAreas; },
+ getIsWidgetAreaOpen: function() { return getIsWidgetAreaOpen; },
+ getParentWidgetAreaBlock: function() { return getParentWidgetAreaBlock; },
+ getReferenceWidgetBlocks: function() { return getReferenceWidgetBlocks; },
+ getWidget: function() { return getWidget; },
+ getWidgetAreaForWidgetId: function() { return getWidgetAreaForWidgetId; },
+ getWidgetAreas: function() { return selectors_getWidgetAreas; },
+ getWidgets: function() { return selectors_getWidgets; },
+ isInserterOpened: function() { return isInserterOpened; },
+ isListViewOpened: function() { return isListViewOpened; },
+ isSavingWidgetAreas: function() { return isSavingWidgetAreas; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-widgets/build-module/blocks/widget-area/index.js
+var widget_area_namespaceObject = {};
+__webpack_require__.r(widget_area_namespaceObject);
+__webpack_require__.d(widget_area_namespaceObject, {
+ metadata: function() { return metadata; },
+ name: function() { return widget_area_name; },
+ settings: function() { return settings; }
+});
+
+;// CONCATENATED MODULE: external ["wp","element"]
+var external_wp_element_namespaceObject = window["wp"]["element"];
+;// CONCATENATED MODULE: external ["wp","blocks"]
+var external_wp_blocks_namespaceObject = window["wp"]["blocks"];
+;// CONCATENATED MODULE: external ["wp","data"]
+var external_wp_data_namespaceObject = window["wp"]["data"];
+;// CONCATENATED MODULE: external ["wp","deprecated"]
+var external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
+var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
+;// CONCATENATED MODULE: external ["wp","blockLibrary"]
+var external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
+;// CONCATENATED MODULE: external ["wp","coreData"]
+var external_wp_coreData_namespaceObject = window["wp"]["coreData"];
+;// CONCATENATED MODULE: external ["wp","widgets"]
+var external_wp_widgets_namespaceObject = window["wp"]["widgets"];
+;// CONCATENATED MODULE: external ["wp","preferences"]
+var external_wp_preferences_namespaceObject = window["wp"]["preferences"];
+;// CONCATENATED MODULE: external ["wp","apiFetch"]
+var external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"];
+var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/reducer.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Controls the open state of the widget areas.
+ *
+ * @param {Object} state Redux state.
+ * @param {Object} action Redux action.
+ *
+ * @return {Array} Updated state.
+ */
+function widgetAreasOpenState(state = {}, action) {
+ const {
+ type
+ } = action;
+ switch (type) {
+ case 'SET_WIDGET_AREAS_OPEN_STATE':
+ {
+ return action.widgetAreasOpenState;
+ }
+ case 'SET_IS_WIDGET_AREA_OPEN':
+ {
+ const {
+ clientId,
+ isOpen
+ } = action;
+ return {
+ ...state,
+ [clientId]: isOpen
+ };
+ }
+ default:
+ {
+ return state;
+ }
+ }
+}
+
+/**
+ * Reducer to set the block inserter panel open or closed.
+ *
+ * Note: this reducer interacts with the list view panel reducer
+ * to make sure that only one of the two panels is open at the same time.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ */
+function blockInserterPanel(state = false, action) {
+ switch (action.type) {
+ case 'SET_IS_LIST_VIEW_OPENED':
+ return action.isOpen ? false : state;
+ case 'SET_IS_INSERTER_OPENED':
+ return action.value;
+ }
+ return state;
+}
+
+/**
+ * Reducer to set the list view panel open or closed.
+ *
+ * Note: this reducer interacts with the inserter panel reducer
+ * to make sure that only one of the two panels is open at the same time.
+ *
+ * @param {Object} state Current state.
+ * @param {Object} action Dispatched action.
+ */
+function listViewPanel(state = false, action) {
+ switch (action.type) {
+ case 'SET_IS_INSERTER_OPENED':
+ return action.value ? false : state;
+ case 'SET_IS_LIST_VIEW_OPENED':
+ return action.isOpen;
+ }
+ return state;
+}
+/* harmony default export */ var reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
+ blockInserterPanel,
+ listViewPanel,
+ widgetAreasOpenState
+}));
+
+;// CONCATENATED MODULE: external ["wp","i18n"]
+var external_wp_i18n_namespaceObject = window["wp"]["i18n"];
+;// CONCATENATED MODULE: external ["wp","notices"]
+var external_wp_notices_namespaceObject = window["wp"]["notices"];
+// EXTERNAL MODULE: ./node_modules/classnames/index.js
+var classnames = __webpack_require__(4403);
+var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
+;// CONCATENATED MODULE: external ["wp","components"]
+var external_wp_components_namespaceObject = window["wp"]["components"];
+;// CONCATENATED MODULE: external ["wp","primitives"]
+var external_wp_primitives_namespaceObject = window["wp"]["primitives"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/check.js
+
+/**
+ * WordPress dependencies
+ */
+
+const check = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M16.7 7.1l-6.3 8.5-3.3-2.5-.9 1.2 4.5 3.4L17.9 8z"
+}));
+/* harmony default export */ var library_check = (check);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/star-filled.js
+
+/**
+ * WordPress dependencies
+ */
+
+const starFilled = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M11.776 4.454a.25.25 0 01.448 0l2.069 4.192a.25.25 0 00.188.137l4.626.672a.25.25 0 01.139.426l-3.348 3.263a.25.25 0 00-.072.222l.79 4.607a.25.25 0 01-.362.263l-4.138-2.175a.25.25 0 00-.232 0l-4.138 2.175a.25.25 0 01-.363-.263l.79-4.607a.25.25 0 00-.071-.222L4.754 9.881a.25.25 0 01.139-.426l4.626-.672a.25.25 0 00.188-.137l2.069-4.192z"
+}));
+/* harmony default export */ var star_filled = (starFilled);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/star-empty.js
+
+/**
+ * WordPress dependencies
+ */
+
+const starEmpty = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ fillRule: "evenodd",
+ d: "M9.706 8.646a.25.25 0 01-.188.137l-4.626.672a.25.25 0 00-.139.427l3.348 3.262a.25.25 0 01.072.222l-.79 4.607a.25.25 0 00.362.264l4.138-2.176a.25.25 0 01.233 0l4.137 2.175a.25.25 0 00.363-.263l-.79-4.607a.25.25 0 01.072-.222l3.347-3.262a.25.25 0 00-.139-.427l-4.626-.672a.25.25 0 01-.188-.137l-2.069-4.192a.25.25 0 00-.448 0L9.706 8.646zM12 7.39l-.948 1.921a1.75 1.75 0 01-1.317.957l-2.12.308 1.534 1.495c.412.402.6.982.503 1.55l-.362 2.11 1.896-.997a1.75 1.75 0 011.629 0l1.895.997-.362-2.11a1.75 1.75 0 01.504-1.55l1.533-1.495-2.12-.308a1.75 1.75 0 01-1.317-.957L12 7.39z",
+ clipRule: "evenodd"
+}));
+/* harmony default export */ var star_empty = (starEmpty);
+
+;// CONCATENATED MODULE: external ["wp","viewport"]
+var external_wp_viewport_namespaceObject = window["wp"]["viewport"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close-small.js
+
+/**
+ * WordPress dependencies
+ */
+
+const closeSmall = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z"
+}));
+/* harmony default export */ var close_small = (closeSmall);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/actions.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Set a default complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ * @param {string} area Area identifier.
+ *
+ * @return {Object} Action object.
+ */
+const setDefaultComplementaryArea = (scope, area) => ({
+ type: 'SET_DEFAULT_COMPLEMENTARY_AREA',
+ scope,
+ area
+});
+
+/**
+ * Enable the complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ * @param {string} area Area identifier.
+ */
+const enableComplementaryArea = (scope, area) => ({
+ registry,
+ dispatch
+}) => {
+ // Return early if there's no area.
+ if (!area) {
+ return;
+ }
+ const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+ if (!isComplementaryAreaVisible) {
+ registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', true);
+ }
+ dispatch({
+ type: 'ENABLE_COMPLEMENTARY_AREA',
+ scope,
+ area
+ });
+};
+
+/**
+ * Disable the complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ */
+const disableComplementaryArea = scope => ({
+ registry
+}) => {
+ const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+ if (isComplementaryAreaVisible) {
+ registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', false);
+ }
+};
+
+/**
+ * Pins an item.
+ *
+ * @param {string} scope Item scope.
+ * @param {string} item Item identifier.
+ *
+ * @return {Object} Action object.
+ */
+const pinItem = (scope, item) => ({
+ registry
+}) => {
+ // Return early if there's no item.
+ if (!item) {
+ return;
+ }
+ const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+
+ // The item is already pinned, there's nothing to do.
+ if (pinnedItems?.[item] === true) {
+ return;
+ }
+ registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
+ ...pinnedItems,
+ [item]: true
+ });
+};
+
+/**
+ * Unpins an item.
+ *
+ * @param {string} scope Item scope.
+ * @param {string} item Item identifier.
+ */
+const unpinItem = (scope, item) => ({
+ registry
+}) => {
+ // Return early if there's no item.
+ if (!item) {
+ return;
+ }
+ const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+ registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
+ ...pinnedItems,
+ [item]: false
+ });
+};
+
+/**
+ * Returns an action object used in signalling that a feature should be toggled.
+ *
+ * @param {string} scope The feature scope (e.g. core/edit-post).
+ * @param {string} featureName The feature name.
+ */
+function toggleFeature(scope, featureName) {
+ return function ({
+ registry
+ }) {
+ external_wp_deprecated_default()(`dispatch( 'core/interface' ).toggleFeature`, {
+ since: '6.0',
+ alternative: `dispatch( 'core/preferences' ).toggle`
+ });
+ registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(scope, featureName);
+ };
+}
+
+/**
+ * Returns an action object used in signalling that a feature should be set to
+ * a true or false value
+ *
+ * @param {string} scope The feature scope (e.g. core/edit-post).
+ * @param {string} featureName The feature name.
+ * @param {boolean} value The value to set.
+ *
+ * @return {Object} Action object.
+ */
+function setFeatureValue(scope, featureName, value) {
+ return function ({
+ registry
+ }) {
+ external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureValue`, {
+ since: '6.0',
+ alternative: `dispatch( 'core/preferences' ).set`
+ });
+ registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, featureName, !!value);
+ };
+}
+
+/**
+ * Returns an action object used in signalling that defaults should be set for features.
+ *
+ * @param {string} scope The feature scope (e.g. core/edit-post).
+ * @param {Object<string, boolean>} defaults A key/value map of feature names to values.
+ *
+ * @return {Object} Action object.
+ */
+function setFeatureDefaults(scope, defaults) {
+ return function ({
+ registry
+ }) {
+ external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureDefaults`, {
+ since: '6.0',
+ alternative: `dispatch( 'core/preferences' ).setDefaults`
+ });
+ registry.dispatch(external_wp_preferences_namespaceObject.store).setDefaults(scope, defaults);
+ };
+}
+
+/**
+ * Returns an action object used in signalling that the user opened a modal.
+ *
+ * @param {string} name A string that uniquely identifies the modal.
+ *
+ * @return {Object} Action object.
+ */
+function openModal(name) {
+ return {
+ type: 'OPEN_MODAL',
+ name
+ };
+}
+
+/**
+ * Returns an action object signalling that the user closed a modal.
+ *
+ * @return {Object} Action object.
+ */
+function closeModal() {
+ return {
+ type: 'CLOSE_MODAL'
+ };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/selectors.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Returns the complementary area that is active in a given scope.
+ *
+ * @param {Object} state Global application state.
+ * @param {string} scope Item scope.
+ *
+ * @return {string | null | undefined} The complementary area that is active in the given scope.
+ */
+const getActiveComplementaryArea = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
+ const isComplementaryAreaVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+
+ // Return `undefined` to indicate that the user has never toggled
+ // visibility, this is the vanilla default. Other code relies on this
+ // nuance in the return value.
+ if (isComplementaryAreaVisible === undefined) {
+ return undefined;
+ }
+
+ // Return `null` to indicate the user hid the complementary area.
+ if (isComplementaryAreaVisible === false) {
+ return null;
+ }
+ return state?.complementaryAreas?.[scope];
+});
+const isComplementaryAreaLoading = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
+ const isVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+ const identifier = state?.complementaryAreas?.[scope];
+ return isVisible && identifier === undefined;
+});
+
+/**
+ * Returns a boolean indicating if an item is pinned or not.
+ *
+ * @param {Object} state Global application state.
+ * @param {string} scope Scope.
+ * @param {string} item Item to check.
+ *
+ * @return {boolean} True if the item is pinned and false otherwise.
+ */
+const isItemPinned = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, item) => {
+ var _pinnedItems$item;
+ const pinnedItems = select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+ return (_pinnedItems$item = pinnedItems?.[item]) !== null && _pinnedItems$item !== void 0 ? _pinnedItems$item : true;
+});
+
+/**
+ * Returns a boolean indicating whether a feature is active for a particular
+ * scope.
+ *
+ * @param {Object} state The store state.
+ * @param {string} scope The scope of the feature (e.g. core/edit-post).
+ * @param {string} featureName The name of the feature.
+ *
+ * @return {boolean} Is the feature enabled?
+ */
+const isFeatureActive = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, featureName) => {
+ external_wp_deprecated_default()(`select( 'core/interface' ).isFeatureActive( scope, featureName )`, {
+ since: '6.0',
+ alternative: `select( 'core/preferences' ).get( scope, featureName )`
+ });
+ return !!select(external_wp_preferences_namespaceObject.store).get(scope, featureName);
+});
+
+/**
+ * Returns true if a modal is active, or false otherwise.
+ *
+ * @param {Object} state Global application state.
+ * @param {string} modalName A string that uniquely identifies the modal.
+ *
+ * @return {boolean} Whether the modal is active.
+ */
+function isModalActive(state, modalName) {
+ return state.activeModal === modalName;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/reducer.js
+/**
+ * WordPress dependencies
+ */
+
+function complementaryAreas(state = {}, action) {
+ switch (action.type) {
+ case 'SET_DEFAULT_COMPLEMENTARY_AREA':
+ {
+ const {
+ scope,
+ area
+ } = action;
+
+ // If there's already an area, don't overwrite it.
+ if (state[scope]) {
+ return state;
+ }
+ return {
+ ...state,
+ [scope]: area
+ };
+ }
+ case 'ENABLE_COMPLEMENTARY_AREA':
+ {
+ const {
+ scope,
+ area
+ } = action;
+ return {
+ ...state,
+ [scope]: area
+ };
+ }
+ }
+ return state;
+}
+
+/**
+ * Reducer for storing the name of the open modal, or null if no modal is open.
+ *
+ * @param {Object} state Previous state.
+ * @param {Object} action Action object containing the `name` of the modal
+ *
+ * @return {Object} Updated state
+ */
+function activeModal(state = null, action) {
+ switch (action.type) {
+ case 'OPEN_MODAL':
+ return action.name;
+ case 'CLOSE_MODAL':
+ return null;
+ }
+ return state;
+}
+/* harmony default export */ var store_reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
+ complementaryAreas,
+ activeModal
+}));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/constants.js
+/**
+ * The identifier for the data store.
+ *
+ * @type {string}
+ */
+const STORE_NAME = 'core/interface';
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Store definition for the interface namespace.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
+ *
+ * @type {Object}
+ */
+const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
+ reducer: store_reducer,
+ actions: actions_namespaceObject,
+ selectors: selectors_namespaceObject
+});
+
+// Once we build a more generic persistence plugin that works across types of stores
+// we'd be able to replace this with a register call.
+(0,external_wp_data_namespaceObject.register)(store);
+
+;// CONCATENATED MODULE: external ["wp","plugins"]
+var external_wp_plugins_namespaceObject = window["wp"]["plugins"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/complementary-area-context/index.js
+/**
+ * WordPress dependencies
+ */
+
+/* harmony default export */ var complementary_area_context = ((0,external_wp_plugins_namespaceObject.withPluginContext)((context, ownProps) => {
+ return {
+ icon: ownProps.icon || context.icon,
+ identifier: ownProps.identifier || `${context.name}/${ownProps.name}`
+ };
+}));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/complementary-area-toggle/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function ComplementaryAreaToggle({
+ as = external_wp_components_namespaceObject.Button,
+ scope,
+ identifier,
+ icon,
+ selectedIcon,
+ name,
+ ...props
+}) {
+ const ComponentToUse = as;
+ const isSelected = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getActiveComplementaryArea(scope) === identifier, [identifier, scope]);
+ const {
+ enableComplementaryArea,
+ disableComplementaryArea
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+ return (0,external_wp_element_namespaceObject.createElement)(ComponentToUse, {
+ icon: selectedIcon && isSelected ? selectedIcon : icon,
+ "aria-controls": identifier.replace('/', ':'),
+ onClick: () => {
+ if (isSelected) {
+ disableComplementaryArea(scope);
+ } else {
+ enableComplementaryArea(scope, identifier);
+ }
+ },
+ ...props
+ });
+}
+/* harmony default export */ var complementary_area_toggle = (complementary_area_context(ComplementaryAreaToggle));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/complementary-area-header/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+const ComplementaryAreaHeader = ({
+ smallScreenTitle,
+ children,
+ className,
+ toggleButtonProps
+}) => {
+ const toggleButton = (0,external_wp_element_namespaceObject.createElement)(complementary_area_toggle, {
+ icon: close_small,
+ ...toggleButtonProps
+ });
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "components-panel__header interface-complementary-area-header__small"
+ }, smallScreenTitle && (0,external_wp_element_namespaceObject.createElement)("span", {
+ className: "interface-complementary-area-header__small-title"
+ }, smallScreenTitle), toggleButton), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: classnames_default()('components-panel__header', 'interface-complementary-area-header', className),
+ tabIndex: -1
+ }, children, toggleButton));
+};
+/* harmony default export */ var complementary_area_header = (ComplementaryAreaHeader);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/action-item/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+const noop = () => {};
+function ActionItemSlot({
+ name,
+ as: Component = external_wp_components_namespaceObject.ButtonGroup,
+ fillProps = {},
+ bubblesVirtually,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Slot, {
+ name: name,
+ bubblesVirtually: bubblesVirtually,
+ fillProps: fillProps
+ }, fills => {
+ if (!external_wp_element_namespaceObject.Children.toArray(fills).length) {
+ return null;
+ }
+
+ // Special handling exists for backward compatibility.
+ // It ensures that menu items created by plugin authors aren't
+ // duplicated with automatically injected menu items coming
+ // from pinnable plugin sidebars.
+ // @see https://github.com/WordPress/gutenberg/issues/14457
+ const initializedByPlugins = [];
+ external_wp_element_namespaceObject.Children.forEach(fills, ({
+ props: {
+ __unstableExplicitMenuItem,
+ __unstableTarget
+ }
+ }) => {
+ if (__unstableTarget && __unstableExplicitMenuItem) {
+ initializedByPlugins.push(__unstableTarget);
+ }
+ });
+ const children = external_wp_element_namespaceObject.Children.map(fills, child => {
+ if (!child.props.__unstableExplicitMenuItem && initializedByPlugins.includes(child.props.__unstableTarget)) {
+ return null;
+ }
+ return child;
+ });
+ return (0,external_wp_element_namespaceObject.createElement)(Component, {
+ ...props
+ }, children);
+ });
+}
+function ActionItem({
+ name,
+ as: Component = external_wp_components_namespaceObject.Button,
+ onClick,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
+ name: name
+ }, ({
+ onClick: fpOnClick
+ }) => {
+ return (0,external_wp_element_namespaceObject.createElement)(Component, {
+ onClick: onClick || fpOnClick ? (...args) => {
+ (onClick || noop)(...args);
+ (fpOnClick || noop)(...args);
+ } : undefined,
+ ...props
+ });
+ });
+}
+ActionItem.Slot = ActionItemSlot;
+/* harmony default export */ var action_item = (ActionItem);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/complementary-area-more-menu-item/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+const PluginsMenuItem = ({
+ // Menu item is marked with unstable prop for backward compatibility.
+ // They are removed so they don't leak to DOM elements.
+ // @see https://github.com/WordPress/gutenberg/issues/14457
+ __unstableExplicitMenuItem,
+ __unstableTarget,
+ ...restProps
+}) => (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+ ...restProps
+});
+function ComplementaryAreaMoreMenuItem({
+ scope,
+ target,
+ __unstableExplicitMenuItem,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(complementary_area_toggle, {
+ as: toggleProps => {
+ return (0,external_wp_element_namespaceObject.createElement)(action_item, {
+ __unstableExplicitMenuItem: __unstableExplicitMenuItem,
+ __unstableTarget: `${scope}/${target}`,
+ as: PluginsMenuItem,
+ name: `${scope}/plugin-more-menu`,
+ ...toggleProps
+ });
+ },
+ role: "menuitemcheckbox",
+ selectedIcon: library_check,
+ name: target,
+ scope: scope,
+ ...props
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/pinned-items/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+function PinnedItems({
+ scope,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
+ name: `PinnedItems/${scope}`,
+ ...props
+ });
+}
+function PinnedItemsSlot({
+ scope,
+ className,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Slot, {
+ name: `PinnedItems/${scope}`,
+ ...props
+ }, fills => fills?.length > 0 && (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: classnames_default()(className, 'interface-pinned-items')
+ }, fills));
+}
+PinnedItems.Slot = PinnedItemsSlot;
+/* harmony default export */ var pinned_items = (PinnedItems);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/complementary-area/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+function ComplementaryAreaSlot({
+ scope,
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Slot, {
+ name: `ComplementaryArea/${scope}`,
+ ...props
+ });
+}
+function ComplementaryAreaFill({
+ scope,
+ children,
+ className,
+ id
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
+ name: `ComplementaryArea/${scope}`
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ id: id,
+ className: className
+ }, children));
+}
+function useAdjustComplementaryListener(scope, identifier, activeArea, isActive, isSmall) {
+ const previousIsSmall = (0,external_wp_element_namespaceObject.useRef)(false);
+ const shouldOpenWhenNotSmall = (0,external_wp_element_namespaceObject.useRef)(false);
+ const {
+ enableComplementaryArea,
+ disableComplementaryArea
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ // If the complementary area is active and the editor is switching from
+ // a big to a small window size.
+ if (isActive && isSmall && !previousIsSmall.current) {
+ disableComplementaryArea(scope);
+ // Flag the complementary area to be reopened when the window size
+ // goes from small to big.
+ shouldOpenWhenNotSmall.current = true;
+ } else if (
+ // If there is a flag indicating the complementary area should be
+ // enabled when we go from small to big window size and we are going
+ // from a small to big window size.
+ shouldOpenWhenNotSmall.current && !isSmall && previousIsSmall.current) {
+ // Remove the flag indicating the complementary area should be
+ // enabled.
+ shouldOpenWhenNotSmall.current = false;
+ enableComplementaryArea(scope, identifier);
+ } else if (
+ // If the flag is indicating the current complementary should be
+ // reopened but another complementary area becomes active, remove
+ // the flag.
+ shouldOpenWhenNotSmall.current && activeArea && activeArea !== identifier) {
+ shouldOpenWhenNotSmall.current = false;
+ }
+ if (isSmall !== previousIsSmall.current) {
+ previousIsSmall.current = isSmall;
+ }
+ }, [isActive, isSmall, scope, identifier, activeArea, disableComplementaryArea, enableComplementaryArea]);
+}
+function ComplementaryArea({
+ children,
+ className,
+ closeLabel = (0,external_wp_i18n_namespaceObject.__)('Close plugin'),
+ identifier,
+ header,
+ headerClassName,
+ icon,
+ isPinnable = true,
+ panelClassName,
+ scope,
+ name,
+ smallScreenTitle,
+ title,
+ toggleShortcut,
+ isActiveByDefault,
+ showIconLabels = false
+}) {
+ const {
+ isLoading,
+ isActive,
+ isPinned,
+ activeArea,
+ isSmall,
+ isLarge
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getActiveComplementaryArea,
+ isComplementaryAreaLoading,
+ isItemPinned
+ } = select(store);
+ const _activeArea = getActiveComplementaryArea(scope);
+ return {
+ isLoading: isComplementaryAreaLoading(scope),
+ isActive: _activeArea === identifier,
+ isPinned: isItemPinned(scope, identifier),
+ activeArea: _activeArea,
+ isSmall: select(external_wp_viewport_namespaceObject.store).isViewportMatch('< medium'),
+ isLarge: select(external_wp_viewport_namespaceObject.store).isViewportMatch('large')
+ };
+ }, [identifier, scope]);
+ useAdjustComplementaryListener(scope, identifier, activeArea, isActive, isSmall);
+ const {
+ enableComplementaryArea,
+ disableComplementaryArea,
+ pinItem,
+ unpinItem
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ // Set initial visibility: For large screens, enable if it's active by
+ // default. For small screens, always initially disable.
+ if (isActiveByDefault && activeArea === undefined && !isSmall) {
+ enableComplementaryArea(scope, identifier);
+ } else if (activeArea === undefined && isSmall) {
+ disableComplementaryArea(scope, identifier);
+ }
+ }, [activeArea, isActiveByDefault, scope, identifier, isSmall, enableComplementaryArea, disableComplementaryArea]);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, isPinnable && (0,external_wp_element_namespaceObject.createElement)(pinned_items, {
+ scope: scope
+ }, isPinned && (0,external_wp_element_namespaceObject.createElement)(complementary_area_toggle, {
+ scope: scope,
+ identifier: identifier,
+ isPressed: isActive && (!showIconLabels || isLarge),
+ "aria-expanded": isActive,
+ "aria-disabled": isLoading,
+ label: title,
+ icon: showIconLabels ? library_check : icon,
+ showTooltip: !showIconLabels,
+ variant: showIconLabels ? 'tertiary' : undefined
+ })), name && isPinnable && (0,external_wp_element_namespaceObject.createElement)(ComplementaryAreaMoreMenuItem, {
+ target: name,
+ scope: scope,
+ icon: icon
+ }, title), isActive && (0,external_wp_element_namespaceObject.createElement)(ComplementaryAreaFill, {
+ className: classnames_default()('interface-complementary-area', className),
+ scope: scope,
+ id: identifier.replace('/', ':')
+ }, (0,external_wp_element_namespaceObject.createElement)(complementary_area_header, {
+ className: headerClassName,
+ closeLabel: closeLabel,
+ onClose: () => disableComplementaryArea(scope),
+ smallScreenTitle: smallScreenTitle,
+ toggleButtonProps: {
+ label: closeLabel,
+ shortcut: toggleShortcut,
+ scope,
+ identifier
+ }
+ }, header || (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("strong", null, title), isPinnable && (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ className: "interface-complementary-area__pin-unpin-item",
+ icon: isPinned ? star_filled : star_empty,
+ label: isPinned ? (0,external_wp_i18n_namespaceObject.__)('Unpin from toolbar') : (0,external_wp_i18n_namespaceObject.__)('Pin to toolbar'),
+ onClick: () => (isPinned ? unpinItem : pinItem)(scope, identifier),
+ isPressed: isPinned,
+ "aria-expanded": isPinned
+ }))), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Panel, {
+ className: panelClassName
+ }, children)));
+}
+const ComplementaryAreaWrapped = complementary_area_context(ComplementaryArea);
+ComplementaryAreaWrapped.Slot = ComplementaryAreaSlot;
+/* harmony default export */ var complementary_area = (ComplementaryAreaWrapped);
+
+;// CONCATENATED MODULE: external ["wp","compose"]
+var external_wp_compose_namespaceObject = window["wp"]["compose"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/navigable-region/index.js
+
+/**
+ * External dependencies
+ */
+
+function NavigableRegion({
+ children,
+ className,
+ ariaLabel,
+ as: Tag = 'div',
+ ...props
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(Tag, {
+ className: classnames_default()('interface-navigable-region', className),
+ "aria-label": ariaLabel,
+ role: "region",
+ tabIndex: "-1",
+ ...props
+ }, children);
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/interface-skeleton/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function useHTMLClass(className) {
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ const element = document && document.querySelector(`html:not(.${className})`);
+ if (!element) {
+ return;
+ }
+ element.classList.toggle(className);
+ return () => {
+ element.classList.toggle(className);
+ };
+ }, [className]);
+}
+const headerVariants = {
+ hidden: {
+ opacity: 0
+ },
+ hover: {
+ opacity: 1,
+ transition: {
+ type: 'tween',
+ delay: 0.2,
+ delayChildren: 0.2
+ }
+ },
+ distractionFreeInactive: {
+ opacity: 1,
+ transition: {
+ delay: 0
+ }
+ }
+};
+function InterfaceSkeleton({
+ isDistractionFree,
+ footer,
+ header,
+ editorNotices,
+ sidebar,
+ secondarySidebar,
+ notices,
+ content,
+ contentProps,
+ actions,
+ labels,
+ className,
+ enableRegionNavigation = true,
+ // Todo: does this need to be a prop.
+ // Can we use a dependency to keyboard-shortcuts directly?
+ shortcuts
+}, ref) {
+ const navigateRegionsProps = (0,external_wp_components_namespaceObject.__unstableUseNavigateRegions)(shortcuts);
+ useHTMLClass('interface-interface-skeleton__html-container');
+ const defaultLabels = {
+ /* translators: accessibility text for the top bar landmark region. */
+ header: (0,external_wp_i18n_namespaceObject.__)('Header'),
+ /* translators: accessibility text for the content landmark region. */
+ body: (0,external_wp_i18n_namespaceObject.__)('Content'),
+ /* translators: accessibility text for the secondary sidebar landmark region. */
+ secondarySidebar: (0,external_wp_i18n_namespaceObject.__)('Block Library'),
+ /* translators: accessibility text for the settings landmark region. */
+ sidebar: (0,external_wp_i18n_namespaceObject.__)('Settings'),
+ /* translators: accessibility text for the publish landmark region. */
+ actions: (0,external_wp_i18n_namespaceObject.__)('Publish'),
+ /* translators: accessibility text for the footer landmark region. */
+ footer: (0,external_wp_i18n_namespaceObject.__)('Footer')
+ };
+ const mergedLabels = {
+ ...defaultLabels,
+ ...labels
+ };
+ return (0,external_wp_element_namespaceObject.createElement)("div", {
+ ...(enableRegionNavigation ? navigateRegionsProps : {}),
+ ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, enableRegionNavigation ? navigateRegionsProps.ref : undefined]),
+ className: classnames_default()(className, 'interface-interface-skeleton', navigateRegionsProps.className, !!footer && 'has-footer')
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "interface-interface-skeleton__editor"
+ }, !!header && (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ as: external_wp_components_namespaceObject.__unstableMotion.div,
+ className: "interface-interface-skeleton__header",
+ "aria-label": mergedLabels.header,
+ initial: isDistractionFree ? 'hidden' : 'distractionFreeInactive',
+ whileHover: isDistractionFree ? 'hover' : 'distractionFreeInactive',
+ animate: isDistractionFree ? 'hidden' : 'distractionFreeInactive',
+ variants: headerVariants,
+ transition: isDistractionFree ? {
+ type: 'tween',
+ delay: 0.8
+ } : undefined
+ }, header), isDistractionFree && (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "interface-interface-skeleton__header"
+ }, editorNotices), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "interface-interface-skeleton__body"
+ }, !!secondarySidebar && (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ className: "interface-interface-skeleton__secondary-sidebar",
+ ariaLabel: mergedLabels.secondarySidebar
+ }, secondarySidebar), !!notices && (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "interface-interface-skeleton__notices"
+ }, notices), (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ className: "interface-interface-skeleton__content",
+ ariaLabel: mergedLabels.body,
+ ...contentProps
+ }, content), !!sidebar && (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ className: "interface-interface-skeleton__sidebar",
+ ariaLabel: mergedLabels.sidebar
+ }, sidebar), !!actions && (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ className: "interface-interface-skeleton__actions",
+ ariaLabel: mergedLabels.actions
+ }, actions))), !!footer && (0,external_wp_element_namespaceObject.createElement)(NavigableRegion, {
+ className: "interface-interface-skeleton__footer",
+ ariaLabel: mergedLabels.footer
+ }, footer));
+}
+/* harmony default export */ var interface_skeleton = ((0,external_wp_element_namespaceObject.forwardRef)(InterfaceSkeleton));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
+
+/**
+ * WordPress dependencies
+ */
+
+const moreVertical = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
+}));
+/* harmony default export */ var more_vertical = (moreVertical);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/more-menu-dropdown/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+function MoreMenuDropdown({
+ as: DropdownComponent = external_wp_components_namespaceObject.DropdownMenu,
+ className,
+ /* translators: button label text should, if possible, be under 16 characters. */
+ label = (0,external_wp_i18n_namespaceObject.__)('Options'),
+ popoverProps,
+ toggleProps,
+ children
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(DropdownComponent, {
+ className: classnames_default()('interface-more-menu-dropdown', className),
+ icon: more_vertical,
+ label: label,
+ popoverProps: {
+ placement: 'bottom-end',
+ ...popoverProps,
+ className: classnames_default()('interface-more-menu-dropdown__content', popoverProps?.className)
+ },
+ toggleProps: {
+ tooltipPosition: 'bottom',
+ ...toggleProps
+ }
+ }, onClose => children(onClose));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/index.js
+
+
+
+;// CONCATENATED MODULE: external ["wp","blockEditor"]
+var external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/transformers.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Converts a widget entity record into a block.
+ *
+ * @param {Object} widget The widget entity record.
+ * @return {Object} a block (converted from the entity record).
+ */
+function transformWidgetToBlock(widget) {
+ if (widget.id_base === 'block') {
+ const parsedBlocks = (0,external_wp_blocks_namespaceObject.parse)(widget.instance.raw.content, {
+ __unstableSkipAutop: true
+ });
+ if (!parsedBlocks.length) {
+ return (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)((0,external_wp_blocks_namespaceObject.createBlock)('core/paragraph', {}, []), widget.id);
+ }
+ return (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)(parsedBlocks[0], widget.id);
+ }
+ let attributes;
+ if (widget._embedded.about[0].is_multi) {
+ attributes = {
+ idBase: widget.id_base,
+ instance: widget.instance
+ };
+ } else {
+ attributes = {
+ id: widget.id
+ };
+ }
+ return (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)((0,external_wp_blocks_namespaceObject.createBlock)('core/legacy-widget', attributes, []), widget.id);
+}
+
+/**
+ * Converts a block to a widget entity record.
+ *
+ * @param {Object} block The block.
+ * @param {Object?} relatedWidget A related widget entity record from the API (optional).
+ * @return {Object} the widget object (converted from block).
+ */
+function transformBlockToWidget(block, relatedWidget = {}) {
+ let widget;
+ const isValidLegacyWidgetBlock = block.name === 'core/legacy-widget' && (block.attributes.id || block.attributes.instance);
+ if (isValidLegacyWidgetBlock) {
+ var _block$attributes$id, _block$attributes$idB, _block$attributes$ins;
+ widget = {
+ ...relatedWidget,
+ id: (_block$attributes$id = block.attributes.id) !== null && _block$attributes$id !== void 0 ? _block$attributes$id : relatedWidget.id,
+ id_base: (_block$attributes$idB = block.attributes.idBase) !== null && _block$attributes$idB !== void 0 ? _block$attributes$idB : relatedWidget.id_base,
+ instance: (_block$attributes$ins = block.attributes.instance) !== null && _block$attributes$ins !== void 0 ? _block$attributes$ins : relatedWidget.instance
+ };
+ } else {
+ widget = {
+ ...relatedWidget,
+ id_base: 'block',
+ instance: {
+ raw: {
+ content: (0,external_wp_blocks_namespaceObject.serialize)(block)
+ }
+ }
+ };
+ }
+
+ // Delete read-only properties.
+ delete widget.rendered;
+ delete widget.rendered_form;
+ return widget;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/utils.js
+/**
+ * "Kind" of the navigation post.
+ *
+ * @type {string}
+ */
+const KIND = 'root';
+
+/**
+ * "post type" of the navigation post.
+ *
+ * @type {string}
+ */
+const WIDGET_AREA_ENTITY_TYPE = 'sidebar';
+
+/**
+ * "post type" of the widget area post.
+ *
+ * @type {string}
+ */
+const POST_TYPE = 'postType';
+
+/**
+ * Builds an ID for a new widget area post.
+ *
+ * @param {number} widgetAreaId Widget area id.
+ * @return {string} An ID.
+ */
+const buildWidgetAreaPostId = widgetAreaId => `widget-area-${widgetAreaId}`;
+
+/**
+ * Builds an ID for a global widget areas post.
+ *
+ * @return {string} An ID.
+ */
+const buildWidgetAreasPostId = () => `widget-areas`;
+
+/**
+ * Builds a query to resolve sidebars.
+ *
+ * @return {Object} Query.
+ */
+function buildWidgetAreasQuery() {
+ return {
+ per_page: -1
+ };
+}
+
+/**
+ * Builds a query to resolve widgets.
+ *
+ * @return {Object} Query.
+ */
+function buildWidgetsQuery() {
+ return {
+ per_page: -1,
+ _embed: 'about'
+ };
+}
+
+/**
+ * Creates a stub post with given id and set of blocks. Used as a governing entity records
+ * for all widget areas.
+ *
+ * @param {string} id Post ID.
+ * @param {Array} blocks The list of blocks.
+ * @return {Object} A stub post object formatted in compliance with the data layer.
+ */
+const createStubPost = (id, blocks) => ({
+ id,
+ slug: id,
+ status: 'draft',
+ type: 'page',
+ blocks,
+ meta: {
+ widgetAreaId: id
+ }
+});
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/constants.js
+/**
+ * Module Constants
+ */
+const constants_STORE_NAME = 'core/edit-widgets';
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/actions.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+/**
+ * Persists a stub post with given ID to core data store. The post is meant to be in-memory only and
+ * shouldn't be saved via the API.
+ *
+ * @param {string} id Post ID.
+ * @param {Array} blocks Blocks the post should consist of.
+ * @return {Object} The post object.
+ */
+const persistStubPost = (id, blocks) => ({
+ registry
+}) => {
+ const stubPost = createStubPost(id, blocks);
+ registry.dispatch(external_wp_coreData_namespaceObject.store).receiveEntityRecords(KIND, POST_TYPE, stubPost, {
+ id: stubPost.id
+ }, false);
+ return stubPost;
+};
+
+/**
+ * Converts all the blocks from edited widget areas into widgets,
+ * and submits a batch request to save everything at once.
+ *
+ * Creates a snackbar notice on either success or error.
+ *
+ * @return {Function} An action creator.
+ */
+const saveEditedWidgetAreas = () => async ({
+ select,
+ dispatch,
+ registry
+}) => {
+ const editedWidgetAreas = select.getEditedWidgetAreas();
+ if (!editedWidgetAreas?.length) {
+ return;
+ }
+ try {
+ await dispatch.saveWidgetAreas(editedWidgetAreas);
+ registry.dispatch(external_wp_notices_namespaceObject.store).createSuccessNotice((0,external_wp_i18n_namespaceObject.__)('Widgets saved.'), {
+ type: 'snackbar'
+ });
+ } catch (e) {
+ registry.dispatch(external_wp_notices_namespaceObject.store).createErrorNotice( /* translators: %s: The error message. */
+ (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('There was an error. %s'), e.message), {
+ type: 'snackbar'
+ });
+ }
+};
+
+/**
+ * Converts all the blocks from specified widget areas into widgets,
+ * and submits a batch request to save everything at once.
+ *
+ * @param {Object[]} widgetAreas Widget areas to save.
+ * @return {Function} An action creator.
+ */
+const saveWidgetAreas = widgetAreas => async ({
+ dispatch,
+ registry
+}) => {
+ try {
+ for (const widgetArea of widgetAreas) {
+ await dispatch.saveWidgetArea(widgetArea.id);
+ }
+ } finally {
+ // saveEditedEntityRecord resets the resolution status, let's fix it manually.
+ await registry.dispatch(external_wp_coreData_namespaceObject.store).finishResolution('getEntityRecord', KIND, WIDGET_AREA_ENTITY_TYPE, buildWidgetAreasQuery());
+ }
+};
+
+/**
+ * Converts all the blocks from a widget area specified by ID into widgets,
+ * and submits a batch request to save everything at once.
+ *
+ * @param {string} widgetAreaId ID of the widget area to process.
+ * @return {Function} An action creator.
+ */
+const saveWidgetArea = widgetAreaId => async ({
+ dispatch,
+ select,
+ registry
+}) => {
+ const widgets = select.getWidgets();
+ const post = registry.select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(KIND, POST_TYPE, buildWidgetAreaPostId(widgetAreaId));
+
+ // Get all widgets from this area
+ const areaWidgets = Object.values(widgets).filter(({
+ sidebar
+ }) => sidebar === widgetAreaId);
+
+ // Remove all duplicate reference widget instances for legacy widgets.
+ // Why? We filter out the widgets with duplicate IDs to prevent adding more than one instance of a widget
+ // implemented using a function. WordPress doesn't support having more than one instance of these, if you try to
+ // save multiple instances of these in different sidebars you will run into undefined behaviors.
+ const usedReferenceWidgets = [];
+ const widgetsBlocks = post.blocks.filter(block => {
+ const {
+ id
+ } = block.attributes;
+ if (block.name === 'core/legacy-widget' && id) {
+ if (usedReferenceWidgets.includes(id)) {
+ return false;
+ }
+ usedReferenceWidgets.push(id);
+ }
+ return true;
+ });
+
+ // Determine which widgets have been deleted. We can tell if a widget is
+ // deleted and not just moved to a different area by looking to see if
+ // getWidgetAreaForWidgetId() finds something.
+ const deletedWidgets = [];
+ for (const widget of areaWidgets) {
+ const widgetsNewArea = select.getWidgetAreaForWidgetId(widget.id);
+ if (!widgetsNewArea) {
+ deletedWidgets.push(widget);
+ }
+ }
+ const batchMeta = [];
+ const batchTasks = [];
+ const sidebarWidgetsIds = [];
+ for (let i = 0; i < widgetsBlocks.length; i++) {
+ const block = widgetsBlocks[i];
+ const widgetId = (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block);
+ const oldWidget = widgets[widgetId];
+ const widget = transformBlockToWidget(block, oldWidget);
+
+ // We'll replace the null widgetId after save, but we track it here
+ // since order is important.
+ sidebarWidgetsIds.push(widgetId);
+
+ // Check oldWidget as widgetId might refer to an ID which has been
+ // deleted, e.g. if a deleted block is restored via undo after saving.
+ if (oldWidget) {
+ // Update an existing widget.
+ registry.dispatch(external_wp_coreData_namespaceObject.store).editEntityRecord('root', 'widget', widgetId, {
+ ...widget,
+ sidebar: widgetAreaId
+ }, {
+ undoIgnore: true
+ });
+ const hasEdits = registry.select(external_wp_coreData_namespaceObject.store).hasEditsForEntityRecord('root', 'widget', widgetId);
+ if (!hasEdits) {
+ continue;
+ }
+ batchTasks.push(({
+ saveEditedEntityRecord
+ }) => saveEditedEntityRecord('root', 'widget', widgetId));
+ } else {
+ // Create a new widget.
+ batchTasks.push(({
+ saveEntityRecord
+ }) => saveEntityRecord('root', 'widget', {
+ ...widget,
+ sidebar: widgetAreaId
+ }));
+ }
+ batchMeta.push({
+ block,
+ position: i,
+ clientId: block.clientId
+ });
+ }
+ for (const widget of deletedWidgets) {
+ batchTasks.push(({
+ deleteEntityRecord
+ }) => deleteEntityRecord('root', 'widget', widget.id, {
+ force: true
+ }));
+ }
+ const records = await registry.dispatch(external_wp_coreData_namespaceObject.store).__experimentalBatch(batchTasks);
+ const preservedRecords = records.filter(record => !record.hasOwnProperty('deleted'));
+ const failedWidgetNames = [];
+ for (let i = 0; i < preservedRecords.length; i++) {
+ const widget = preservedRecords[i];
+ const {
+ block,
+ position
+ } = batchMeta[i];
+
+ // Set __internalWidgetId on the block. This will be persisted to the
+ // store when we dispatch receiveEntityRecords( post ) below.
+ post.blocks[position].attributes.__internalWidgetId = widget.id;
+ const error = registry.select(external_wp_coreData_namespaceObject.store).getLastEntitySaveError('root', 'widget', widget.id);
+ if (error) {
+ failedWidgetNames.push(block.attributes?.name || block?.name);
+ }
+ if (!sidebarWidgetsIds[position]) {
+ sidebarWidgetsIds[position] = widget.id;
+ }
+ }
+ if (failedWidgetNames.length) {
+ throw new Error((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: List of widget names */
+ (0,external_wp_i18n_namespaceObject.__)('Could not save the following widgets: %s.'), failedWidgetNames.join(', ')));
+ }
+ registry.dispatch(external_wp_coreData_namespaceObject.store).editEntityRecord(KIND, WIDGET_AREA_ENTITY_TYPE, widgetAreaId, {
+ widgets: sidebarWidgetsIds
+ }, {
+ undoIgnore: true
+ });
+ dispatch(trySaveWidgetArea(widgetAreaId));
+ registry.dispatch(external_wp_coreData_namespaceObject.store).receiveEntityRecords(KIND, POST_TYPE, post, undefined);
+};
+const trySaveWidgetArea = widgetAreaId => ({
+ registry
+}) => {
+ registry.dispatch(external_wp_coreData_namespaceObject.store).saveEditedEntityRecord(KIND, WIDGET_AREA_ENTITY_TYPE, widgetAreaId, {
+ throwOnError: true
+ });
+};
+
+/**
+ * Sets the clientId stored for a particular widgetId.
+ *
+ * @param {number} clientId Client id.
+ * @param {number} widgetId Widget id.
+ *
+ * @return {Object} Action.
+ */
+function setWidgetIdForClientId(clientId, widgetId) {
+ return {
+ type: 'SET_WIDGET_ID_FOR_CLIENT_ID',
+ clientId,
+ widgetId
+ };
+}
+
+/**
+ * Sets the open state of all the widget areas.
+ *
+ * @param {Object} widgetAreasOpenState The open states of all the widget areas.
+ *
+ * @return {Object} Action.
+ */
+function setWidgetAreasOpenState(widgetAreasOpenState) {
+ return {
+ type: 'SET_WIDGET_AREAS_OPEN_STATE',
+ widgetAreasOpenState
+ };
+}
+
+/**
+ * Sets the open state of the widget area.
+ *
+ * @param {string} clientId The clientId of the widget area.
+ * @param {boolean} isOpen Whether the widget area should be opened.
+ *
+ * @return {Object} Action.
+ */
+function setIsWidgetAreaOpen(clientId, isOpen) {
+ return {
+ type: 'SET_IS_WIDGET_AREA_OPEN',
+ clientId,
+ isOpen
+ };
+}
+
+/**
+ * Returns an action object used to open/close the inserter.
+ *
+ * @param {boolean|Object} value Whether the inserter should be
+ * opened (true) or closed (false).
+ * To specify an insertion point,
+ * use an object.
+ * @param {string} value.rootClientId The root client ID to insert at.
+ * @param {number} value.insertionIndex The index to insert at.
+ *
+ * @return {Object} Action object.
+ */
+function setIsInserterOpened(value) {
+ return {
+ type: 'SET_IS_INSERTER_OPENED',
+ value
+ };
+}
+
+/**
+ * Returns an action object used to open/close the list view.
+ *
+ * @param {boolean} isOpen A boolean representing whether the list view should be opened or closed.
+ * @return {Object} Action object.
+ */
+function setIsListViewOpened(isOpen) {
+ return {
+ type: 'SET_IS_LIST_VIEW_OPENED',
+ isOpen
+ };
+}
+
+/**
+ * Returns an action object signalling that the user closed the sidebar.
+ *
+ * @return {Object} Action creator.
+ */
+const closeGeneralSidebar = () => ({
+ registry
+}) => {
+ registry.dispatch(store).disableComplementaryArea(constants_STORE_NAME);
+};
+
+/**
+ * Action that handles moving a block between widget areas
+ *
+ * @param {string} clientId The clientId of the block to move.
+ * @param {string} widgetAreaId The id of the widget area to move the block to.
+ */
+const moveBlockToWidgetArea = (clientId, widgetAreaId) => async ({
+ dispatch,
+ select,
+ registry
+}) => {
+ const sourceRootClientId = registry.select(external_wp_blockEditor_namespaceObject.store).getBlockRootClientId(clientId);
+
+ // Search the top level blocks (widget areas) for the one with the matching
+ // id attribute. Makes the assumption that all top-level blocks are widget
+ // areas.
+ const widgetAreas = registry.select(external_wp_blockEditor_namespaceObject.store).getBlocks();
+ const destinationWidgetAreaBlock = widgetAreas.find(({
+ attributes
+ }) => attributes.id === widgetAreaId);
+ const destinationRootClientId = destinationWidgetAreaBlock.clientId;
+
+ // Get the index for moving to the end of the destination widget area.
+ const destinationInnerBlocksClientIds = registry.select(external_wp_blockEditor_namespaceObject.store).getBlockOrder(destinationRootClientId);
+ const destinationIndex = destinationInnerBlocksClientIds.length;
+
+ // Reveal the widget area, if it's not open.
+ const isDestinationWidgetAreaOpen = select.getIsWidgetAreaOpen(destinationRootClientId);
+ if (!isDestinationWidgetAreaOpen) {
+ dispatch.setIsWidgetAreaOpen(destinationRootClientId, true);
+ }
+
+ // Move the block.
+ registry.dispatch(external_wp_blockEditor_namespaceObject.store).moveBlocksToPosition([clientId], sourceRootClientId, destinationRootClientId, destinationIndex);
+};
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/resolvers.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+/**
+ * Creates a "stub" widgets post reflecting all available widget areas. The
+ * post is meant as a convenient to only exists in runtime and should never be saved. It
+ * enables a convenient way of editing the widgets by using a regular post editor.
+ *
+ * Fetches all widgets from all widgets aras, converts them into blocks, and hydrates a new post with them.
+ *
+ * @return {Function} An action creator.
+ */
+const getWidgetAreas = () => async ({
+ dispatch,
+ registry
+}) => {
+ const query = buildWidgetAreasQuery();
+ const widgetAreas = await registry.resolveSelect(external_wp_coreData_namespaceObject.store).getEntityRecords(KIND, WIDGET_AREA_ENTITY_TYPE, query);
+ const widgetAreaBlocks = [];
+ const sortedWidgetAreas = widgetAreas.sort((a, b) => {
+ if (a.id === 'wp_inactive_widgets') {
+ return 1;
+ }
+ if (b.id === 'wp_inactive_widgets') {
+ return -1;
+ }
+ return 0;
+ });
+ for (const widgetArea of sortedWidgetAreas) {
+ widgetAreaBlocks.push((0,external_wp_blocks_namespaceObject.createBlock)('core/widget-area', {
+ id: widgetArea.id,
+ name: widgetArea.name
+ }));
+ if (!widgetArea.widgets.length) {
+ // If this widget area has no widgets, it won't get a post setup by
+ // the getWidgets resolver.
+ dispatch(persistStubPost(buildWidgetAreaPostId(widgetArea.id), []));
+ }
+ }
+ const widgetAreasOpenState = {};
+ widgetAreaBlocks.forEach((widgetAreaBlock, index) => {
+ // Defaults to open the first widget area.
+ widgetAreasOpenState[widgetAreaBlock.clientId] = index === 0;
+ });
+ dispatch(setWidgetAreasOpenState(widgetAreasOpenState));
+ dispatch(persistStubPost(buildWidgetAreasPostId(), widgetAreaBlocks));
+};
+
+/**
+ * Fetches all widgets from all widgets ares, and groups them by widget area Id.
+ *
+ * @return {Function} An action creator.
+ */
+const getWidgets = () => async ({
+ dispatch,
+ registry
+}) => {
+ const query = buildWidgetsQuery();
+ const widgets = await registry.resolveSelect(external_wp_coreData_namespaceObject.store).getEntityRecords('root', 'widget', query);
+ const groupedBySidebar = {};
+ for (const widget of widgets) {
+ const block = transformWidgetToBlock(widget);
+ groupedBySidebar[widget.sidebar] = groupedBySidebar[widget.sidebar] || [];
+ groupedBySidebar[widget.sidebar].push(block);
+ }
+ for (const sidebarId in groupedBySidebar) {
+ if (groupedBySidebar.hasOwnProperty(sidebarId)) {
+ // Persist the actual post containing the widget block
+ dispatch(persistStubPost(buildWidgetAreaPostId(sidebarId), groupedBySidebar[sidebarId]));
+ }
+ }
+};
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/selectors.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+const EMPTY_INSERTION_POINT = {
+ rootClientId: undefined,
+ insertionIndex: undefined
+};
+
+/**
+ * Returns all API widgets.
+ *
+ * @return {Object[]} API List of widgets.
+ */
+const selectors_getWidgets = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => () => {
+ const widgets = select(external_wp_coreData_namespaceObject.store).getEntityRecords('root', 'widget', buildWidgetsQuery());
+ return (
+ // Key widgets by their ID.
+ widgets?.reduce((allWidgets, widget) => ({
+ ...allWidgets,
+ [widget.id]: widget
+ }), {}) || {}
+ );
+});
+
+/**
+ * Returns API widget data for a particular widget ID.
+ *
+ * @param {number} id Widget ID.
+ *
+ * @return {Object} API widget data for a particular widget ID.
+ */
+const getWidget = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, id) => {
+ const widgets = select(constants_STORE_NAME).getWidgets();
+ return widgets[id];
+});
+
+/**
+ * Returns all API widget areas.
+ *
+ * @return {Object[]} API List of widget areas.
+ */
+const selectors_getWidgetAreas = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => () => {
+ const query = buildWidgetAreasQuery();
+ return select(external_wp_coreData_namespaceObject.store).getEntityRecords(KIND, WIDGET_AREA_ENTITY_TYPE, query);
+});
+
+/**
+ * Returns widgetArea containing a block identify by given widgetId
+ *
+ * @param {string} widgetId The ID of the widget.
+ * @return {Object} Containing widget area.
+ */
+const getWidgetAreaForWidgetId = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, widgetId) => {
+ const widgetAreas = select(constants_STORE_NAME).getWidgetAreas();
+ return widgetAreas.find(widgetArea => {
+ const post = select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(KIND, POST_TYPE, buildWidgetAreaPostId(widgetArea.id));
+ const blockWidgetIds = post.blocks.map(block => (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block));
+ return blockWidgetIds.includes(widgetId);
+ });
+});
+
+/**
+ * Given a child client id, returns the parent widget area block.
+ *
+ * @param {string} clientId The client id of a block in a widget area.
+ *
+ * @return {WPBlock} The widget area block.
+ */
+const getParentWidgetAreaBlock = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientId) => {
+ const {
+ getBlock,
+ getBlockName,
+ getBlockParents
+ } = select(external_wp_blockEditor_namespaceObject.store);
+ const blockParents = getBlockParents(clientId);
+ const widgetAreaClientId = blockParents.find(parentClientId => getBlockName(parentClientId) === 'core/widget-area');
+ return getBlock(widgetAreaClientId);
+});
+
+/**
+ * Returns all edited widget area entity records.
+ *
+ * @return {Object[]} List of edited widget area entity records.
+ */
+const getEditedWidgetAreas = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, ids) => {
+ let widgetAreas = select(constants_STORE_NAME).getWidgetAreas();
+ if (!widgetAreas) {
+ return [];
+ }
+ if (ids) {
+ widgetAreas = widgetAreas.filter(({
+ id
+ }) => ids.includes(id));
+ }
+ return widgetAreas.filter(({
+ id
+ }) => select(external_wp_coreData_namespaceObject.store).hasEditsForEntityRecord(KIND, POST_TYPE, buildWidgetAreaPostId(id))).map(({
+ id
+ }) => select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(KIND, WIDGET_AREA_ENTITY_TYPE, id));
+});
+
+/**
+ * Returns all blocks representing reference widgets.
+ *
+ * @param {string} referenceWidgetName Optional. If given, only reference widgets with this name will be returned.
+ * @return {Array} List of all blocks representing reference widgets
+ */
+const getReferenceWidgetBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, referenceWidgetName = null) => {
+ const results = [];
+ const widgetAreas = select(constants_STORE_NAME).getWidgetAreas();
+ for (const _widgetArea of widgetAreas) {
+ const post = select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(KIND, POST_TYPE, buildWidgetAreaPostId(_widgetArea.id));
+ for (const block of post.blocks) {
+ if (block.name === 'core/legacy-widget' && (!referenceWidgetName || block.attributes?.referenceWidgetName === referenceWidgetName)) {
+ results.push(block);
+ }
+ }
+ }
+ return results;
+});
+
+/**
+ * Returns true if any widget area is currently being saved.
+ *
+ * @return {boolean} True if any widget area is currently being saved. False otherwise.
+ */
+const isSavingWidgetAreas = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => () => {
+ const widgetAreasIds = select(constants_STORE_NAME).getWidgetAreas()?.map(({
+ id
+ }) => id);
+ if (!widgetAreasIds) {
+ return false;
+ }
+ for (const id of widgetAreasIds) {
+ const isSaving = select(external_wp_coreData_namespaceObject.store).isSavingEntityRecord(KIND, WIDGET_AREA_ENTITY_TYPE, id);
+ if (isSaving) {
+ return true;
+ }
+ }
+ const widgetIds = [...Object.keys(select(constants_STORE_NAME).getWidgets()), undefined // account for new widgets without an ID
+ ];
+
+ for (const id of widgetIds) {
+ const isSaving = select(external_wp_coreData_namespaceObject.store).isSavingEntityRecord('root', 'widget', id);
+ if (isSaving) {
+ return true;
+ }
+ }
+ return false;
+});
+
+/**
+ * Gets whether the widget area is opened.
+ *
+ * @param {Array} state The open state of the widget areas.
+ * @param {string} clientId The clientId of the widget area.
+ *
+ * @return {boolean} True if the widget area is open.
+ */
+const getIsWidgetAreaOpen = (state, clientId) => {
+ const {
+ widgetAreasOpenState
+ } = state;
+ return !!widgetAreasOpenState[clientId];
+};
+
+/**
+ * Returns true if the inserter is opened.
+ *
+ * @param {Object} state Global application state.
+ *
+ * @return {boolean} Whether the inserter is opened.
+ */
+function isInserterOpened(state) {
+ return !!state.blockInserterPanel;
+}
+
+/**
+ * Get the insertion point for the inserter.
+ *
+ * @param {Object} state Global application state.
+ *
+ * @return {Object} The root client ID and index to insert at.
+ */
+function __experimentalGetInsertionPoint(state) {
+ if (typeof state.blockInserterPanel === 'boolean') {
+ return EMPTY_INSERTION_POINT;
+ }
+ return state.blockInserterPanel;
+}
+
+/**
+ * Returns true if a block can be inserted into a widget area.
+ *
+ * @param {Array} state The open state of the widget areas.
+ * @param {string} blockName The name of the block being inserted.
+ *
+ * @return {boolean} True if the block can be inserted in a widget area.
+ */
+const canInsertBlockInWidgetArea = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, blockName) => {
+ // Widget areas are always top-level blocks, which getBlocks will return.
+ const widgetAreas = select(external_wp_blockEditor_namespaceObject.store).getBlocks();
+
+ // Makes an assumption that a block that can be inserted into one
+ // widget area can be inserted into any widget area. Uses the first
+ // widget area for testing whether the block can be inserted.
+ const [firstWidgetArea] = widgetAreas;
+ return select(external_wp_blockEditor_namespaceObject.store).canInsertBlockType(blockName, firstWidgetArea.clientId);
+});
+
+/**
+ * Returns true if the list view is opened.
+ *
+ * @param {Object} state Global application state.
+ *
+ * @return {boolean} Whether the list view is opened.
+ */
+function isListViewOpened(state) {
+ return state.listViewPanel;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/store/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+/**
+ * Block editor data store configuration.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#register
+ *
+ * @type {Object}
+ */
+const storeConfig = {
+ reducer: reducer,
+ selectors: store_selectors_namespaceObject,
+ resolvers: resolvers_namespaceObject,
+ actions: store_actions_namespaceObject
+};
+
+/**
+ * Store definition for the edit widgets namespace.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
+ *
+ * @type {Object}
+ */
+const store_store = (0,external_wp_data_namespaceObject.createReduxStore)(constants_STORE_NAME, storeConfig);
+(0,external_wp_data_namespaceObject.register)(store_store);
+
+// This package uses a few in-memory post types as wrappers for convenience.
+// This middleware prevents any network requests related to these types as they are
+// bound to fail anyway.
+external_wp_apiFetch_default().use(function (options, next) {
+ if (options.path?.indexOf('/wp/v2/types/widget-area') === 0) {
+ return Promise.resolve({});
+ }
+ return next(options);
+});
+
+;// CONCATENATED MODULE: external ["wp","hooks"]
+var external_wp_hooks_namespaceObject = window["wp"]["hooks"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/filters/move-to-widget-area.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+const withMoveToWidgetAreaToolbarItem = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
+ const {
+ clientId,
+ name: blockName
+ } = props;
+ const {
+ widgetAreas,
+ currentWidgetAreaId,
+ canInsertBlockInWidgetArea
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ // Component won't display for a widget area, so don't run selectors.
+ if (blockName === 'core/widget-area') {
+ return {};
+ }
+ const selectors = select(store_store);
+ const widgetAreaBlock = selectors.getParentWidgetAreaBlock(clientId);
+ return {
+ widgetAreas: selectors.getWidgetAreas(),
+ currentWidgetAreaId: widgetAreaBlock?.attributes?.id,
+ canInsertBlockInWidgetArea: selectors.canInsertBlockInWidgetArea(blockName)
+ };
+ }, [clientId, blockName]);
+ const {
+ moveBlockToWidgetArea
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const hasMultipleWidgetAreas = widgetAreas?.length > 1;
+ const isMoveToWidgetAreaVisible = blockName !== 'core/widget-area' && hasMultipleWidgetAreas && canInsertBlockInWidgetArea;
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(BlockEdit, {
+ ...props
+ }), isMoveToWidgetAreaVisible && (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockControls, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_widgets_namespaceObject.MoveToWidgetArea, {
+ widgetAreas: widgetAreas,
+ currentWidgetAreaId: currentWidgetAreaId,
+ onSelect: widgetAreaId => {
+ moveBlockToWidgetArea(props.clientId, widgetAreaId);
+ }
+ })));
+}, 'withMoveToWidgetAreaToolbarItem');
+(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/edit-widgets/block-edit', withMoveToWidgetAreaToolbarItem);
+
+;// CONCATENATED MODULE: external ["wp","mediaUtils"]
+var external_wp_mediaUtils_namespaceObject = window["wp"]["mediaUtils"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/filters/replace-media-upload.js
+/**
+ * WordPress dependencies
+ */
+
+
+const replaceMediaUpload = () => external_wp_mediaUtils_namespaceObject.MediaUpload;
+(0,external_wp_hooks_namespaceObject.addFilter)('editor.MediaUpload', 'core/edit-widgets/replace-media-upload', replaceMediaUpload);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/filters/index.js
+/**
+ * Internal dependencies
+ */
+
+
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/blocks/widget-area/edit/use-is-dragging-within.js
+/**
+ * WordPress dependencies
+ */
+
+
+/** @typedef {import('@wordpress/element').RefObject} RefObject */
+
+/**
+ * A React hook to determine if it's dragging within the target element.
+ *
+ * @param {RefObject<HTMLElement>} elementRef The target elementRef object.
+ *
+ * @return {boolean} Is dragging within the target element.
+ */
+const useIsDraggingWithin = elementRef => {
+ const [isDraggingWithin, setIsDraggingWithin] = (0,external_wp_element_namespaceObject.useState)(false);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ const {
+ ownerDocument
+ } = elementRef.current;
+ function handleDragStart(event) {
+ // Check the first time when the dragging starts.
+ handleDragEnter(event);
+ }
+
+ // Set to false whenever the user cancel the drag event by either releasing the mouse or press Escape.
+ function handleDragEnd() {
+ setIsDraggingWithin(false);
+ }
+ function handleDragEnter(event) {
+ // Check if the current target is inside the item element.
+ if (elementRef.current.contains(event.target)) {
+ setIsDraggingWithin(true);
+ } else {
+ setIsDraggingWithin(false);
+ }
+ }
+
+ // Bind these events to the document to catch all drag events.
+ // Ideally, we can also use `event.relatedTarget`, but sadly that doesn't work in Safari.
+ ownerDocument.addEventListener('dragstart', handleDragStart);
+ ownerDocument.addEventListener('dragend', handleDragEnd);
+ ownerDocument.addEventListener('dragenter', handleDragEnter);
+ return () => {
+ ownerDocument.removeEventListener('dragstart', handleDragStart);
+ ownerDocument.removeEventListener('dragend', handleDragEnd);
+ ownerDocument.removeEventListener('dragenter', handleDragEnter);
+ };
+ }, []);
+ return isDraggingWithin;
+};
+/* harmony default export */ var use_is_dragging_within = (useIsDraggingWithin);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/blocks/widget-area/edit/inner-blocks.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function WidgetAreaInnerBlocks({
+ id
+}) {
+ const [blocks, onInput, onChange] = (0,external_wp_coreData_namespaceObject.useEntityBlockEditor)('root', 'postType');
+ const innerBlocksRef = (0,external_wp_element_namespaceObject.useRef)();
+ const isDraggingWithinInnerBlocks = use_is_dragging_within(innerBlocksRef);
+ const shouldHighlightDropZone = isDraggingWithinInnerBlocks;
+ // Using the experimental hook so that we can control the className of the element.
+ const innerBlocksProps = (0,external_wp_blockEditor_namespaceObject.useInnerBlocksProps)({
+ ref: innerBlocksRef
+ }, {
+ value: blocks,
+ onInput,
+ onChange,
+ templateLock: false,
+ renderAppender: external_wp_blockEditor_namespaceObject.InnerBlocks.ButtonBlockAppender
+ });
+ return (0,external_wp_element_namespaceObject.createElement)("div", {
+ "data-widget-area-id": id,
+ className: classnames_default()('wp-block-widget-area__inner-blocks block-editor-inner-blocks editor-styles-wrapper', {
+ 'wp-block-widget-area__highlight-drop-zone': shouldHighlightDropZone
+ })
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ ...innerBlocksProps
+ }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/blocks/widget-area/edit/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+/** @typedef {import('@wordpress/element').RefObject} RefObject */
+
+function WidgetAreaEdit({
+ clientId,
+ className,
+ attributes: {
+ id,
+ name
+ }
+}) {
+ const isOpen = (0,external_wp_data_namespaceObject.useSelect)(select => select(store_store).getIsWidgetAreaOpen(clientId), [clientId]);
+ const {
+ setIsWidgetAreaOpen
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const wrapper = (0,external_wp_element_namespaceObject.useRef)();
+ const setOpen = (0,external_wp_element_namespaceObject.useCallback)(openState => setIsWidgetAreaOpen(clientId, openState), [clientId]);
+ const isDragging = useIsDragging(wrapper);
+ const isDraggingWithin = use_is_dragging_within(wrapper);
+ const [openedWhileDragging, setOpenedWhileDragging] = (0,external_wp_element_namespaceObject.useState)(false);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ if (!isDragging) {
+ setOpenedWhileDragging(false);
+ return;
+ }
+ if (isDraggingWithin && !isOpen) {
+ setOpen(true);
+ setOpenedWhileDragging(true);
+ } else if (!isDraggingWithin && isOpen && openedWhileDragging) {
+ setOpen(false);
+ }
+ }, [isOpen, isDragging, isDraggingWithin, openedWhileDragging]);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Panel, {
+ className: className,
+ ref: wrapper
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.PanelBody, {
+ title: name,
+ opened: isOpen,
+ onToggle: () => {
+ setIsWidgetAreaOpen(clientId, !isOpen);
+ },
+ scrollAfterOpen: !isDragging
+ }, ({
+ opened
+ }) =>
+ // This is required to ensure LegacyWidget blocks are not
+ // unmounted when the panel is collapsed. Unmounting legacy
+ // widgets may have unintended consequences (e.g. TinyMCE
+ // not being properly reinitialized)
+ (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.__unstableDisclosureContent, {
+ className: "wp-block-widget-area__panel-body-content",
+ visible: opened
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_coreData_namespaceObject.EntityProvider, {
+ kind: "root",
+ type: "postType",
+ id: `widget-area-${id}`
+ }, (0,external_wp_element_namespaceObject.createElement)(WidgetAreaInnerBlocks, {
+ id: id
+ })))));
+}
+
+/**
+ * A React hook to determine if dragging is active.
+ *
+ * @param {RefObject<HTMLElement>} elementRef The target elementRef object.
+ *
+ * @return {boolean} Is dragging within the entire document.
+ */
+const useIsDragging = elementRef => {
+ const [isDragging, setIsDragging] = (0,external_wp_element_namespaceObject.useState)(false);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ const {
+ ownerDocument
+ } = elementRef.current;
+ function handleDragStart() {
+ setIsDragging(true);
+ }
+ function handleDragEnd() {
+ setIsDragging(false);
+ }
+ ownerDocument.addEventListener('dragstart', handleDragStart);
+ ownerDocument.addEventListener('dragend', handleDragEnd);
+ return () => {
+ ownerDocument.removeEventListener('dragstart', handleDragStart);
+ ownerDocument.removeEventListener('dragend', handleDragEnd);
+ };
+ }, []);
+ return isDragging;
+};
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/blocks/widget-area/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+const metadata = {
+ name: "core/widget-area",
+ category: "widgets",
+ attributes: {
+ id: {
+ type: "string"
+ },
+ name: {
+ type: "string"
+ }
+ },
+ supports: {
+ html: false,
+ inserter: false,
+ customClassName: false,
+ reusable: false,
+ __experimentalToolbar: false,
+ __experimentalParentSelector: false,
+ __experimentalDisableBlockOverlay: true
+ },
+ editorStyle: "wp-block-widget-area-editor",
+ style: "wp-block-widget-area"
+};
+
+const {
+ name: widget_area_name
+} = metadata;
+
+const settings = {
+ title: (0,external_wp_i18n_namespaceObject.__)('Widget Area'),
+ description: (0,external_wp_i18n_namespaceObject.__)('A widget area container.'),
+ __experimentalLabel: ({
+ name: label
+ }) => label,
+ edit: WidgetAreaEdit
+};
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/error-boundary/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+function CopyButton({
+ text,
+ children
+}) {
+ const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(text);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ variant: "secondary",
+ ref: ref
+ }, children);
+}
+function ErrorBoundaryWarning({
+ message,
+ error
+}) {
+ const actions = [(0,external_wp_element_namespaceObject.createElement)(CopyButton, {
+ key: "copy-error",
+ text: error.stack
+ }, (0,external_wp_i18n_namespaceObject.__)('Copy Error'))];
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.Warning, {
+ className: "edit-widgets-error-boundary",
+ actions: actions
+ }, message);
+}
+class ErrorBoundary extends external_wp_element_namespaceObject.Component {
+ constructor() {
+ super(...arguments);
+ this.state = {
+ error: null
+ };
+ }
+ componentDidCatch(error) {
+ (0,external_wp_hooks_namespaceObject.doAction)('editor.ErrorBoundary.errorLogged', error);
+ }
+ static getDerivedStateFromError(error) {
+ return {
+ error
+ };
+ }
+ render() {
+ if (!this.state.error) {
+ return this.props.children;
+ }
+ return (0,external_wp_element_namespaceObject.createElement)(ErrorBoundaryWarning, {
+ message: (0,external_wp_i18n_namespaceObject.__)('The editor has encountered an unexpected error.'),
+ error: this.state.error
+ });
+ }
+}
+
+;// CONCATENATED MODULE: external ["wp","patterns"]
+var external_wp_patterns_namespaceObject = window["wp"]["patterns"];
+;// CONCATENATED MODULE: external ["wp","keyboardShortcuts"]
+var external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
+;// CONCATENATED MODULE: external ["wp","keycodes"]
+var external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/keyboard-shortcuts/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function KeyboardShortcuts() {
+ const {
+ redo,
+ undo
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_coreData_namespaceObject.store);
+ const {
+ saveEditedWidgetAreas
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const {
+ replaceBlocks
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+ const {
+ getBlockName,
+ getSelectedBlockClientId,
+ getBlockAttributes
+ } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blockEditor_namespaceObject.store);
+ const handleTextLevelShortcut = (event, level) => {
+ event.preventDefault();
+ const destinationBlockName = level === 0 ? 'core/paragraph' : 'core/heading';
+ const currentClientId = getSelectedBlockClientId();
+ if (currentClientId === null) {
+ return;
+ }
+ const blockName = getBlockName(currentClientId);
+ if (blockName !== 'core/paragraph' && blockName !== 'core/heading') {
+ return;
+ }
+ const attributes = getBlockAttributes(currentClientId);
+ const textAlign = blockName === 'core/paragraph' ? 'align' : 'textAlign';
+ const destinationTextAlign = destinationBlockName === 'core/paragraph' ? 'align' : 'textAlign';
+ replaceBlocks(currentClientId, (0,external_wp_blocks_namespaceObject.createBlock)(destinationBlockName, {
+ level,
+ content: attributes.content,
+ ...{
+ [destinationTextAlign]: attributes[textAlign]
+ }
+ }));
+ };
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/undo', event => {
+ undo();
+ event.preventDefault();
+ });
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/redo', event => {
+ redo();
+ event.preventDefault();
+ });
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/save', event => {
+ event.preventDefault();
+ saveEditedWidgetAreas();
+ });
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/transform-heading-to-paragraph', event => handleTextLevelShortcut(event, 0));
+ [1, 2, 3, 4, 5, 6].forEach(level => {
+ //the loop is based off on a constant therefore
+ //the hook will execute the same way every time
+ //eslint-disable-next-line react-hooks/rules-of-hooks
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(`core/edit-widgets/transform-paragraph-to-heading-${level}`, event => handleTextLevelShortcut(event, level));
+ });
+ return null;
+}
+function KeyboardShortcutsRegister() {
+ // Registering the shortcuts.
+ const {
+ registerShortcut
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ registerShortcut({
+ name: 'core/edit-widgets/undo',
+ category: 'global',
+ description: (0,external_wp_i18n_namespaceObject.__)('Undo your last changes.'),
+ keyCombination: {
+ modifier: 'primary',
+ character: 'z'
+ }
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/redo',
+ category: 'global',
+ description: (0,external_wp_i18n_namespaceObject.__)('Redo your last undo.'),
+ keyCombination: {
+ modifier: 'primaryShift',
+ character: 'z'
+ },
+ // Disable on Apple OS because it conflicts with the browser's
+ // history shortcut. It's a fine alias for both Windows and Linux.
+ // Since there's no conflict for Ctrl+Shift+Z on both Windows and
+ // Linux, we keep it as the default for consistency.
+ aliases: (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? [] : [{
+ modifier: 'primary',
+ character: 'y'
+ }]
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/save',
+ category: 'global',
+ description: (0,external_wp_i18n_namespaceObject.__)('Save your changes.'),
+ keyCombination: {
+ modifier: 'primary',
+ character: 's'
+ }
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/keyboard-shortcuts',
+ category: 'main',
+ description: (0,external_wp_i18n_namespaceObject.__)('Display these keyboard shortcuts.'),
+ keyCombination: {
+ modifier: 'access',
+ character: 'h'
+ }
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/next-region',
+ category: 'global',
+ description: (0,external_wp_i18n_namespaceObject.__)('Navigate to the next part of the editor.'),
+ keyCombination: {
+ modifier: 'ctrl',
+ character: '`'
+ },
+ aliases: [{
+ modifier: 'access',
+ character: 'n'
+ }]
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/previous-region',
+ category: 'global',
+ description: (0,external_wp_i18n_namespaceObject.__)('Navigate to the previous part of the editor.'),
+ keyCombination: {
+ modifier: 'ctrlShift',
+ character: '`'
+ },
+ aliases: [{
+ modifier: 'access',
+ character: 'p'
+ }, {
+ modifier: 'ctrlShift',
+ character: '~'
+ }]
+ });
+ registerShortcut({
+ name: 'core/edit-widgets/transform-heading-to-paragraph',
+ category: 'block-library',
+ description: (0,external_wp_i18n_namespaceObject.__)('Transform heading to paragraph.'),
+ keyCombination: {
+ modifier: 'access',
+ character: `0`
+ }
+ });
+ [1, 2, 3, 4, 5, 6].forEach(level => {
+ registerShortcut({
+ name: `core/edit-widgets/transform-paragraph-to-heading-${level}`,
+ category: 'block-library',
+ description: (0,external_wp_i18n_namespaceObject.__)('Transform paragraph to heading.'),
+ keyCombination: {
+ modifier: 'access',
+ character: `${level}`
+ }
+ });
+ });
+ }, [registerShortcut]);
+ return null;
+}
+KeyboardShortcuts.Register = KeyboardShortcutsRegister;
+/* harmony default export */ var keyboard_shortcuts = (KeyboardShortcuts);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/hooks/use-last-selected-widget-area.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+/**
+ * A react hook that returns the client id of the last widget area to have
+ * been selected, or to have a selected block within it.
+ *
+ * @return {string} clientId of the widget area last selected.
+ */
+const useLastSelectedWidgetArea = () => (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getBlockSelectionEnd,
+ getBlockName
+ } = select(external_wp_blockEditor_namespaceObject.store);
+ const selectionEndClientId = getBlockSelectionEnd();
+
+ // If the selected block is a widget area, return its clientId.
+ if (getBlockName(selectionEndClientId) === 'core/widget-area') {
+ return selectionEndClientId;
+ }
+ const {
+ getParentWidgetAreaBlock
+ } = select(store_store);
+ const widgetAreaBlock = getParentWidgetAreaBlock(selectionEndClientId);
+ const widgetAreaBlockClientId = widgetAreaBlock?.clientId;
+ if (widgetAreaBlockClientId) {
+ return widgetAreaBlockClientId;
+ }
+
+ // If no widget area has been selected, return the clientId of the first
+ // area.
+ const {
+ getEntityRecord
+ } = select(external_wp_coreData_namespaceObject.store);
+ const widgetAreasPost = getEntityRecord(KIND, POST_TYPE, buildWidgetAreasPostId());
+ return widgetAreasPost?.blocks[0]?.clientId;
+}, []);
+/* harmony default export */ var use_last_selected_widget_area = (useLastSelectedWidgetArea);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/constants.js
+const ALLOW_REUSABLE_BLOCKS = false;
+const ENABLE_EXPERIMENTAL_FSE_BLOCKS = false;
+
+;// CONCATENATED MODULE: external ["wp","privateApis"]
+var external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/lock-unlock.js
+/**
+ * WordPress dependencies
+ */
+
+const {
+ lock,
+ unlock
+} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I know using unstable features means my theme or plugin will inevitably break in the next version of WordPress.', '@wordpress/edit-widgets');
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/widget-areas-block-editor-provider/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+const {
+ ExperimentalBlockEditorProvider
+} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
+const {
+ PatternsMenuItems
+} = unlock(external_wp_patterns_namespaceObject.privateApis);
+function WidgetAreasBlockEditorProvider({
+ blockEditorSettings,
+ children,
+ ...props
+}) {
+ const mediaPermissions = (0,external_wp_coreData_namespaceObject.useResourcePermissions)('media');
+ const {
+ reusableBlocks,
+ isFixedToolbarActive,
+ keepCaretInsideBlock
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => ({
+ widgetAreas: select(store_store).getWidgetAreas(),
+ widgets: select(store_store).getWidgets(),
+ reusableBlocks: ALLOW_REUSABLE_BLOCKS ? select(external_wp_coreData_namespaceObject.store).getEntityRecords('postType', 'wp_block') : [],
+ isFixedToolbarActive: !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'fixedToolbar'),
+ keepCaretInsideBlock: !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'keepCaretInsideBlock')
+ }), []);
+ const {
+ setIsInserterOpened
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const settings = (0,external_wp_element_namespaceObject.useMemo)(() => {
+ let mediaUploadBlockEditor;
+ if (mediaPermissions.canCreate) {
+ mediaUploadBlockEditor = ({
+ onError,
+ ...argumentsObject
+ }) => {
+ (0,external_wp_mediaUtils_namespaceObject.uploadMedia)({
+ wpAllowedMimeTypes: blockEditorSettings.allowedMimeTypes,
+ onError: ({
+ message
+ }) => onError(message),
+ ...argumentsObject
+ });
+ };
+ }
+ return {
+ ...blockEditorSettings,
+ __experimentalReusableBlocks: reusableBlocks,
+ hasFixedToolbar: isFixedToolbarActive,
+ keepCaretInsideBlock,
+ mediaUpload: mediaUploadBlockEditor,
+ templateLock: 'all',
+ __experimentalSetIsInserterOpened: setIsInserterOpened
+ };
+ }, [blockEditorSettings, isFixedToolbarActive, keepCaretInsideBlock, mediaPermissions.canCreate, reusableBlocks, setIsInserterOpened]);
+ const widgetAreaId = use_last_selected_widget_area();
+ const [blocks, onInput, onChange] = (0,external_wp_coreData_namespaceObject.useEntityBlockEditor)(KIND, POST_TYPE, {
+ id: buildWidgetAreasPostId()
+ });
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.SlotFillProvider, null, (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts.Register, null), (0,external_wp_element_namespaceObject.createElement)(ExperimentalBlockEditorProvider, {
+ value: blocks,
+ onInput: onInput,
+ onChange: onChange,
+ settings: settings,
+ useSubRegistry: false,
+ ...props
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.CopyHandler, null, children), (0,external_wp_element_namespaceObject.createElement)(PatternsMenuItems, {
+ rootClientId: widgetAreaId
+ })));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/drawer-left.js
+
+/**
+ * WordPress dependencies
+ */
+
+const drawerLeft = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ width: "24",
+ height: "24",
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ fillRule: "evenodd",
+ clipRule: "evenodd",
+ d: "M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM8.5 18.5H6c-.3 0-.5-.2-.5-.5V6c0-.3.2-.5.5-.5h2.5v13zm10-.5c0 .3-.2.5-.5.5h-8v-13h8c.3 0 .5.2.5.5v12z"
+}));
+/* harmony default export */ var drawer_left = (drawerLeft);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/drawer-right.js
+
+/**
+ * WordPress dependencies
+ */
+
+const drawerRight = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ width: "24",
+ height: "24",
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ fillRule: "evenodd",
+ clipRule: "evenodd",
+ d: "M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-4 14.5H6c-.3 0-.5-.2-.5-.5V6c0-.3.2-.5.5-.5h8v13zm4.5-.5c0 .3-.2.5-.5.5h-2.5v-13H18c.3 0 .5.2.5.5v12z"
+}));
+/* harmony default export */ var drawer_right = (drawerRight);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/block-default.js
+
+/**
+ * WordPress dependencies
+ */
+
+const blockDefault = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z"
+}));
+/* harmony default export */ var block_default = (blockDefault);
+
+;// CONCATENATED MODULE: external ["wp","url"]
+var external_wp_url_namespaceObject = window["wp"]["url"];
+;// CONCATENATED MODULE: external ["wp","dom"]
+var external_wp_dom_namespaceObject = window["wp"]["dom"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/sidebar/widget-areas.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function WidgetAreas({
+ selectedWidgetAreaId
+}) {
+ const widgetAreas = (0,external_wp_data_namespaceObject.useSelect)(select => select(store_store).getWidgetAreas(), []);
+ const selectedWidgetArea = (0,external_wp_element_namespaceObject.useMemo)(() => selectedWidgetAreaId && widgetAreas?.find(widgetArea => widgetArea.id === selectedWidgetAreaId), [selectedWidgetAreaId, widgetAreas]);
+ let description;
+ if (!selectedWidgetArea) {
+ description = (0,external_wp_i18n_namespaceObject.__)('Widget Areas are global parts in your site’s layout that can accept blocks. These vary by theme, but are typically parts like your Sidebar or Footer.');
+ } else if (selectedWidgetAreaId === 'wp_inactive_widgets') {
+ description = (0,external_wp_i18n_namespaceObject.__)('Blocks in this Widget Area will not be displayed in your site.');
+ } else {
+ description = selectedWidgetArea.description;
+ }
+ return (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-widget-areas"
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-widget-areas__top-container"
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockIcon, {
+ icon: block_default
+ }), (0,external_wp_element_namespaceObject.createElement)("div", null, (0,external_wp_element_namespaceObject.createElement)("p", {
+ // Use `dangerouslySetInnerHTML` to keep backwards
+ // compatibility. Basic markup in the description is an
+ // established feature of WordPress.
+ // @see https://github.com/WordPress/gutenberg/issues/33106
+ dangerouslySetInnerHTML: {
+ __html: (0,external_wp_dom_namespaceObject.safeHTML)(description)
+ }
+ }), widgetAreas?.length === 0 && (0,external_wp_element_namespaceObject.createElement)("p", null, (0,external_wp_i18n_namespaceObject.__)('Your theme does not contain any Widget Areas.')), !selectedWidgetArea && (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ href: (0,external_wp_url_namespaceObject.addQueryArgs)('customize.php', {
+ 'autofocus[panel]': 'widgets',
+ return: window.location.pathname
+ }),
+ variant: "tertiary"
+ }, (0,external_wp_i18n_namespaceObject.__)('Manage with live preview')))));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/sidebar/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+const SIDEBAR_ACTIVE_BY_DEFAULT = external_wp_element_namespaceObject.Platform.select({
+ web: true,
+ native: false
+});
+const BLOCK_INSPECTOR_IDENTIFIER = 'edit-widgets/block-inspector';
+
+// Widget areas were one called block areas, so use 'edit-widgets/block-areas'
+// for backwards compatibility.
+const WIDGET_AREAS_IDENTIFIER = 'edit-widgets/block-areas';
+
+/**
+ * Internal dependencies
+ */
+
+
+function ComplementaryAreaTab({
+ identifier,
+ label,
+ isActive
+}) {
+ const {
+ enableComplementaryArea
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ onClick: () => enableComplementaryArea(store_store.name, identifier),
+ className: classnames_default()('edit-widgets-sidebar__panel-tab', {
+ 'is-active': isActive
+ }),
+ "aria-label": isActive ?
+ // translators: %s: sidebar label e.g: "Widget Areas".
+ (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('%s (selected)'), label) : label,
+ "data-label": label
+ }, label);
+}
+function Sidebar() {
+ const {
+ enableComplementaryArea
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+ const {
+ currentArea,
+ hasSelectedNonAreaBlock,
+ isGeneralSidebarOpen,
+ selectedWidgetAreaBlock
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getSelectedBlock,
+ getBlock,
+ getBlockParentsByBlockName
+ } = select(external_wp_blockEditor_namespaceObject.store);
+ const {
+ getActiveComplementaryArea
+ } = select(store);
+ const selectedBlock = getSelectedBlock();
+ const activeArea = getActiveComplementaryArea(store_store.name);
+ let currentSelection = activeArea;
+ if (!currentSelection) {
+ if (selectedBlock) {
+ currentSelection = BLOCK_INSPECTOR_IDENTIFIER;
+ } else {
+ currentSelection = WIDGET_AREAS_IDENTIFIER;
+ }
+ }
+ let widgetAreaBlock;
+ if (selectedBlock) {
+ if (selectedBlock.name === 'core/widget-area') {
+ widgetAreaBlock = selectedBlock;
+ } else {
+ widgetAreaBlock = getBlock(getBlockParentsByBlockName(selectedBlock.clientId, 'core/widget-area')[0]);
+ }
+ }
+ return {
+ currentArea: currentSelection,
+ hasSelectedNonAreaBlock: !!(selectedBlock && selectedBlock.name !== 'core/widget-area'),
+ isGeneralSidebarOpen: !!activeArea,
+ selectedWidgetAreaBlock: widgetAreaBlock
+ };
+ }, []);
+
+ // currentArea, and isGeneralSidebarOpen are intentionally left out from the dependencies,
+ // because we want to run the effect when a block is selected/unselected and not when the sidebar state changes.
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ if (hasSelectedNonAreaBlock && currentArea === WIDGET_AREAS_IDENTIFIER && isGeneralSidebarOpen) {
+ enableComplementaryArea('core/edit-widgets', BLOCK_INSPECTOR_IDENTIFIER);
+ }
+ if (!hasSelectedNonAreaBlock && currentArea === BLOCK_INSPECTOR_IDENTIFIER && isGeneralSidebarOpen) {
+ enableComplementaryArea('core/edit-widgets', WIDGET_AREAS_IDENTIFIER);
+ }
+ }, [hasSelectedNonAreaBlock, enableComplementaryArea]);
+ return (0,external_wp_element_namespaceObject.createElement)(complementary_area, {
+ className: "edit-widgets-sidebar",
+ header: (0,external_wp_element_namespaceObject.createElement)("ul", null, (0,external_wp_element_namespaceObject.createElement)("li", null, (0,external_wp_element_namespaceObject.createElement)(ComplementaryAreaTab, {
+ identifier: WIDGET_AREAS_IDENTIFIER,
+ label: selectedWidgetAreaBlock ? selectedWidgetAreaBlock.attributes.name : (0,external_wp_i18n_namespaceObject.__)('Widget Areas'),
+ isActive: currentArea === WIDGET_AREAS_IDENTIFIER
+ })), (0,external_wp_element_namespaceObject.createElement)("li", null, (0,external_wp_element_namespaceObject.createElement)(ComplementaryAreaTab, {
+ identifier: BLOCK_INSPECTOR_IDENTIFIER,
+ label: (0,external_wp_i18n_namespaceObject.__)('Block'),
+ isActive: currentArea === BLOCK_INSPECTOR_IDENTIFIER
+ }))),
+ headerClassName: "edit-widgets-sidebar__panel-tabs"
+ /* translators: button label text should, if possible, be under 16 characters. */,
+ title: (0,external_wp_i18n_namespaceObject.__)('Settings'),
+ closeLabel: (0,external_wp_i18n_namespaceObject.__)('Close Settings'),
+ scope: "core/edit-widgets",
+ identifier: currentArea,
+ icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? drawer_left : drawer_right,
+ isActiveByDefault: SIDEBAR_ACTIVE_BY_DEFAULT
+ }, currentArea === WIDGET_AREAS_IDENTIFIER && (0,external_wp_element_namespaceObject.createElement)(WidgetAreas, {
+ selectedWidgetAreaId: selectedWidgetAreaBlock?.attributes.id
+ }), currentArea === BLOCK_INSPECTOR_IDENTIFIER && (hasSelectedNonAreaBlock ? (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockInspector, null) :
+ // Pretend that Widget Areas are part of the UI by not
+ // showing the Block Inspector when one is selected.
+ (0,external_wp_element_namespaceObject.createElement)("span", {
+ className: "block-editor-block-inspector__no-blocks"
+ }, (0,external_wp_i18n_namespaceObject.__)('No block selected.'))));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plus.js
+
+/**
+ * WordPress dependencies
+ */
+
+const plus = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M18 11.2h-5.2V6h-1.6v5.2H6v1.6h5.2V18h1.6v-5.2H18z"
+}));
+/* harmony default export */ var library_plus = (plus);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/list-view.js
+
+/**
+ * WordPress dependencies
+ */
+
+const listView = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ viewBox: "0 0 24 24",
+ xmlns: "http://www.w3.org/2000/svg"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M3 6h11v1.5H3V6Zm3.5 5.5h11V13h-11v-1.5ZM21 17H10v1.5h11V17Z"
+}));
+/* harmony default export */ var list_view = (listView);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/save-button/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function SaveButton() {
+ const {
+ hasEditedWidgetAreaIds,
+ isSaving
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getEditedWidgetAreas,
+ isSavingWidgetAreas
+ } = select(store_store);
+ return {
+ hasEditedWidgetAreaIds: getEditedWidgetAreas()?.length > 0,
+ isSaving: isSavingWidgetAreas()
+ };
+ }, []);
+ const {
+ saveEditedWidgetAreas
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ variant: "primary",
+ isBusy: isSaving,
+ "aria-disabled": isSaving,
+ onClick: isSaving ? undefined : saveEditedWidgetAreas,
+ disabled: !hasEditedWidgetAreaIds
+ }, isSaving ? (0,external_wp_i18n_namespaceObject.__)('Saving…') : (0,external_wp_i18n_namespaceObject.__)('Update'));
+}
+/* harmony default export */ var save_button = (SaveButton);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/undo.js
+
+/**
+ * WordPress dependencies
+ */
+
+const undo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M18.3 11.7c-.6-.6-1.4-.9-2.3-.9H6.7l2.9-3.3-1.1-1-4.5 5L8.5 16l1-1-2.7-2.7H16c.5 0 .9.2 1.3.5 1 1 1 3.4 1 4.5v.3h1.5v-.2c0-1.5 0-4.3-1.5-5.7z"
+}));
+/* harmony default export */ var library_undo = (undo);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/redo.js
+
+/**
+ * WordPress dependencies
+ */
+
+const redo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M15.6 6.5l-1.1 1 2.9 3.3H8c-.9 0-1.7.3-2.3.9-1.4 1.5-1.4 4.2-1.4 5.6v.2h1.5v-.3c0-1.1 0-3.5 1-4.5.3-.3.7-.5 1.3-.5h9.2L14.5 15l1.1 1.1 4.6-4.6-4.6-5z"
+}));
+/* harmony default export */ var library_redo = (redo);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/undo-redo/undo.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+function UndoButton() {
+ const hasUndo = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_coreData_namespaceObject.store).hasUndo(), []);
+ const {
+ undo
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_coreData_namespaceObject.store);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
+ icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_undo : library_redo,
+ label: (0,external_wp_i18n_namespaceObject.__)('Undo'),
+ shortcut: external_wp_keycodes_namespaceObject.displayShortcut.primary('z')
+ // If there are no undo levels we don't want to actually disable this
+ // button, because it will remove focus for keyboard users.
+ // See: https://github.com/WordPress/gutenberg/issues/3486
+ ,
+ "aria-disabled": !hasUndo,
+ onClick: hasUndo ? undo : undefined
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/undo-redo/redo.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+function RedoButton() {
+ const shortcut = (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? external_wp_keycodes_namespaceObject.displayShortcut.primaryShift('z') : external_wp_keycodes_namespaceObject.displayShortcut.primary('y');
+ const hasRedo = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_coreData_namespaceObject.store).hasRedo(), []);
+ const {
+ redo
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_coreData_namespaceObject.store);
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
+ icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_redo : library_undo,
+ label: (0,external_wp_i18n_namespaceObject.__)('Redo'),
+ shortcut: shortcut
+ // If there are no undo levels we don't want to actually disable this
+ // button, because it will remove focus for keyboard users.
+ // See: https://github.com/WordPress/gutenberg/issues/3486
+ ,
+ "aria-disabled": !hasRedo,
+ onClick: hasRedo ? redo : undefined
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/external.js
+
+/**
+ * WordPress dependencies
+ */
+
+const external = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M19.5 4.5h-7V6h4.44l-5.97 5.97 1.06 1.06L18 7.06v4.44h1.5v-7Zm-13 1a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-3H17v3a.5.5 0 0 1-.5.5h-10a.5.5 0 0 1-.5-.5v-10a.5.5 0 0 1 .5-.5h3V5.5h-3Z"
+}));
+/* harmony default export */ var library_external = (external);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/keyboard-shortcut-help-modal/config.js
+/**
+ * WordPress dependencies
+ */
+
+const textFormattingShortcuts = [{
+ keyCombination: {
+ modifier: 'primary',
+ character: 'b'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text bold.')
+}, {
+ keyCombination: {
+ modifier: 'primary',
+ character: 'i'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text italic.')
+}, {
+ keyCombination: {
+ modifier: 'primary',
+ character: 'k'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Convert the selected text into a link.')
+}, {
+ keyCombination: {
+ modifier: 'primaryShift',
+ character: 'k'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Remove a link.')
+}, {
+ keyCombination: {
+ character: '[['
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Insert a link to a post or page.')
+}, {
+ keyCombination: {
+ modifier: 'primary',
+ character: 'u'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Underline the selected text.')
+}, {
+ keyCombination: {
+ modifier: 'access',
+ character: 'd'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Strikethrough the selected text.')
+}, {
+ keyCombination: {
+ modifier: 'access',
+ character: 'x'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text inline code.')
+}, {
+ keyCombination: {
+ modifier: 'access',
+ character: '0'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Convert the current heading to a paragraph.')
+}, {
+ keyCombination: {
+ modifier: 'access',
+ character: '1-6'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Convert the current paragraph or heading to a heading of level 1 to 6.')
+}];
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/keyboard-shortcut-help-modal/shortcut.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+function KeyCombination({
+ keyCombination,
+ forceAriaLabel
+}) {
+ const shortcut = keyCombination.modifier ? external_wp_keycodes_namespaceObject.displayShortcutList[keyCombination.modifier](keyCombination.character) : keyCombination.character;
+ const ariaLabel = keyCombination.modifier ? external_wp_keycodes_namespaceObject.shortcutAriaLabel[keyCombination.modifier](keyCombination.character) : keyCombination.character;
+ const shortcuts = Array.isArray(shortcut) ? shortcut : [shortcut];
+ return (0,external_wp_element_namespaceObject.createElement)("kbd", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-key-combination",
+ "aria-label": forceAriaLabel || ariaLabel
+ }, shortcuts.map((character, index) => {
+ if (character === '+') {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, {
+ key: index
+ }, character);
+ }
+ return (0,external_wp_element_namespaceObject.createElement)("kbd", {
+ key: index,
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-key"
+ }, character);
+ }));
+}
+function Shortcut({
+ description,
+ keyCombination,
+ aliases = [],
+ ariaLabel
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-description"
+ }, description), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-term"
+ }, (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
+ keyCombination: keyCombination,
+ forceAriaLabel: ariaLabel
+ }), aliases.map((alias, index) => (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
+ keyCombination: alias,
+ forceAriaLabel: ariaLabel,
+ key: index
+ }))));
+}
+/* harmony default export */ var keyboard_shortcut_help_modal_shortcut = (Shortcut);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/keyboard-shortcut-help-modal/dynamic-shortcut.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function DynamicShortcut({
+ name
+}) {
+ const {
+ keyCombination,
+ description,
+ aliases
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getShortcutKeyCombination,
+ getShortcutDescription,
+ getShortcutAliases
+ } = select(external_wp_keyboardShortcuts_namespaceObject.store);
+ return {
+ keyCombination: getShortcutKeyCombination(name),
+ aliases: getShortcutAliases(name),
+ description: getShortcutDescription(name)
+ };
+ }, [name]);
+ if (!keyCombination) {
+ return null;
+ }
+ return (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
+ keyCombination: keyCombination,
+ description: description,
+ aliases: aliases
+ });
+}
+/* harmony default export */ var dynamic_shortcut = (DynamicShortcut);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/keyboard-shortcut-help-modal/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+const ShortcutList = ({
+ shortcuts
+}) =>
+/*
+ * Disable reason: The `list` ARIA role is redundant but
+ * Safari+VoiceOver won't announce the list otherwise.
+ */
+/* eslint-disable jsx-a11y/no-redundant-roles */
+(0,external_wp_element_namespaceObject.createElement)("ul", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-list",
+ role: "list"
+}, shortcuts.map((shortcut, index) => (0,external_wp_element_namespaceObject.createElement)("li", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__shortcut",
+ key: index
+}, typeof shortcut === 'string' ? (0,external_wp_element_namespaceObject.createElement)(dynamic_shortcut, {
+ name: shortcut
+}) : (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
+ ...shortcut
+}))))
+/* eslint-enable jsx-a11y/no-redundant-roles */;
+
+const ShortcutSection = ({
+ title,
+ shortcuts,
+ className
+}) => (0,external_wp_element_namespaceObject.createElement)("section", {
+ className: classnames_default()('edit-widgets-keyboard-shortcut-help-modal__section', className)
+}, !!title && (0,external_wp_element_namespaceObject.createElement)("h2", {
+ className: "edit-widgets-keyboard-shortcut-help-modal__section-title"
+}, title), (0,external_wp_element_namespaceObject.createElement)(ShortcutList, {
+ shortcuts: shortcuts
+}));
+const ShortcutCategorySection = ({
+ title,
+ categoryName,
+ additionalShortcuts = []
+}) => {
+ const categoryShortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ return select(external_wp_keyboardShortcuts_namespaceObject.store).getCategoryShortcuts(categoryName);
+ }, [categoryName]);
+ return (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+ title: title,
+ shortcuts: categoryShortcuts.concat(additionalShortcuts)
+ });
+};
+function KeyboardShortcutHelpModal({
+ isModalActive,
+ toggleModal
+}) {
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/keyboard-shortcuts', toggleModal, {
+ bindGlobal: true
+ });
+ if (!isModalActive) {
+ return null;
+ }
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Modal, {
+ className: "edit-widgets-keyboard-shortcut-help-modal",
+ title: (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts'),
+ onRequestClose: toggleModal
+ }, (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+ className: "edit-widgets-keyboard-shortcut-help-modal__main-shortcuts",
+ shortcuts: ['core/edit-widgets/keyboard-shortcuts']
+ }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+ title: (0,external_wp_i18n_namespaceObject.__)('Global shortcuts'),
+ categoryName: "global"
+ }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+ title: (0,external_wp_i18n_namespaceObject.__)('Selection shortcuts'),
+ categoryName: "selection"
+ }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+ title: (0,external_wp_i18n_namespaceObject.__)('Block shortcuts'),
+ categoryName: "block",
+ additionalShortcuts: [{
+ keyCombination: {
+ character: '/'
+ },
+ description: (0,external_wp_i18n_namespaceObject.__)('Change the block type after adding a new paragraph.'),
+ /* translators: The forward-slash character. e.g. '/'. */
+ ariaLabel: (0,external_wp_i18n_namespaceObject.__)('Forward-slash')
+ }]
+ }), (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+ title: (0,external_wp_i18n_namespaceObject.__)('Text formatting'),
+ shortcuts: textFormattingShortcuts
+ }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/more-menu/tools-more-menu-group.js
+
+/**
+ * WordPress dependencies
+ */
+
+const {
+ Fill: ToolsMoreMenuGroup,
+ Slot
+} = (0,external_wp_components_namespaceObject.createSlotFill)('EditWidgetsToolsMoreMenuGroup');
+ToolsMoreMenuGroup.Slot = ({
+ fillProps
+}) => (0,external_wp_element_namespaceObject.createElement)(Slot, {
+ fillProps: fillProps
+}, fills => fills.length > 0 && fills);
+/* harmony default export */ var tools_more_menu_group = (ToolsMoreMenuGroup);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/more-menu/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function MoreMenu() {
+ const [isKeyboardShortcutsModalActive, setIsKeyboardShortcutsModalVisible] = (0,external_wp_element_namespaceObject.useState)(false);
+ const toggleKeyboardShortcutsModal = () => setIsKeyboardShortcutsModalVisible(!isKeyboardShortcutsModalActive);
+ (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/edit-widgets/keyboard-shortcuts', toggleKeyboardShortcutsModal);
+ const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium');
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(MoreMenuDropdown, null, onClose => (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, isLargeViewport && (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+ label: (0,external_wp_i18n_namespaceObject._x)('View', 'noun')
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+ scope: "core/edit-widgets",
+ name: "fixedToolbar",
+ label: (0,external_wp_i18n_namespaceObject.__)('Top toolbar'),
+ info: (0,external_wp_i18n_namespaceObject.__)('Access all block and document tools in a single place'),
+ messageActivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar activated'),
+ messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar deactivated')
+ })), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+ label: (0,external_wp_i18n_namespaceObject.__)('Tools')
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+ onClick: () => {
+ setIsKeyboardShortcutsModalVisible(true);
+ },
+ shortcut: external_wp_keycodes_namespaceObject.displayShortcut.access('h')
+ }, (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts')), (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+ scope: "core/edit-widgets",
+ name: "welcomeGuide",
+ label: (0,external_wp_i18n_namespaceObject.__)('Welcome Guide')
+ }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+ role: "menuitem",
+ icon: library_external,
+ href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/block-based-widgets-editor/'),
+ target: "_blank",
+ rel: "noopener noreferrer"
+ }, (0,external_wp_i18n_namespaceObject.__)('Help'), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
+ as: "span"
+ }, /* translators: accessibility text */
+ (0,external_wp_i18n_namespaceObject.__)('(opens in a new tab)'))), (0,external_wp_element_namespaceObject.createElement)(tools_more_menu_group.Slot, {
+ fillProps: {
+ onClose
+ }
+ })), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+ label: (0,external_wp_i18n_namespaceObject.__)('Preferences')
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+ scope: "core/edit-widgets",
+ name: "keepCaretInsideBlock",
+ label: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block'),
+ info: (0,external_wp_i18n_namespaceObject.__)('Aids screen readers by stopping text caret from leaving blocks.'),
+ messageActivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block activated'),
+ messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block deactivated')
+ }), (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+ scope: "core/edit-widgets",
+ name: "themeStyles",
+ info: (0,external_wp_i18n_namespaceObject.__)('Make the editor look like your theme.'),
+ label: (0,external_wp_i18n_namespaceObject.__)('Use theme styles')
+ }), isLargeViewport && (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+ scope: "core/edit-widgets",
+ name: "showBlockBreadcrumbs",
+ label: (0,external_wp_i18n_namespaceObject.__)('Display block breadcrumbs'),
+ info: (0,external_wp_i18n_namespaceObject.__)('Shows block breadcrumbs at the bottom of the editor.'),
+ messageActivated: (0,external_wp_i18n_namespaceObject.__)('Display block breadcrumbs activated'),
+ messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Display block breadcrumbs deactivated')
+ })))), (0,external_wp_element_namespaceObject.createElement)(KeyboardShortcutHelpModal, {
+ isModalActive: isKeyboardShortcutsModalActive,
+ toggleModal: toggleKeyboardShortcutsModal
+ }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+
+const {
+ useShouldContextualToolbarShow
+} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
+function Header({
+ setListViewToggleElement
+}) {
+ const isMediumViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium');
+ const inserterButton = (0,external_wp_element_namespaceObject.useRef)();
+ const widgetAreaClientId = use_last_selected_widget_area();
+ const isLastSelectedWidgetAreaOpen = (0,external_wp_data_namespaceObject.useSelect)(select => select(store_store).getIsWidgetAreaOpen(widgetAreaClientId), [widgetAreaClientId]);
+ const {
+ isInserterOpen,
+ isListViewOpen
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ isInserterOpened,
+ isListViewOpened
+ } = select(store_store);
+ return {
+ isInserterOpen: isInserterOpened(),
+ isListViewOpen: isListViewOpened()
+ };
+ }, []);
+ const {
+ setIsWidgetAreaOpen,
+ setIsInserterOpened,
+ setIsListViewOpened
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const {
+ selectBlock
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+ const handleClick = () => {
+ if (isInserterOpen) {
+ // Focusing the inserter button closes the inserter popover.
+ setIsInserterOpened(false);
+ } else {
+ if (!isLastSelectedWidgetAreaOpen) {
+ // Select the last selected block if hasn't already.
+ selectBlock(widgetAreaClientId);
+ // Open the last selected widget area when opening the inserter.
+ setIsWidgetAreaOpen(widgetAreaClientId, true);
+ }
+ // The DOM updates resulting from selectBlock() and setIsInserterOpened() calls are applied the
+ // same tick and pretty much in a random order. The inserter is closed if any other part of the
+ // app receives focus. If selectBlock() happens to take effect after setIsInserterOpened() then
+ // the inserter is visible for a brief moment and then gets auto-closed due to focus moving to
+ // the selected block.
+ window.requestAnimationFrame(() => setIsInserterOpened(true));
+ }
+ };
+ const toggleListView = (0,external_wp_element_namespaceObject.useCallback)(() => setIsListViewOpened(!isListViewOpen), [setIsListViewOpened, isListViewOpen]);
+ const {
+ shouldShowContextualToolbar,
+ canFocusHiddenToolbar,
+ fixedToolbarCanBeFocused
+ } = useShouldContextualToolbarShow();
+ // If there's a block toolbar to be focused, disable the focus shortcut for the document toolbar.
+ // There's a fixed block toolbar when the fixed toolbar option is enabled or when the browser width is less than the large viewport.
+ const blockToolbarCanBeFocused = shouldShowContextualToolbar || canFocusHiddenToolbar || fixedToolbarCanBeFocused;
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-header"
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-header__navigable-toolbar-wrapper"
+ }, isMediumViewport && (0,external_wp_element_namespaceObject.createElement)("h1", {
+ className: "edit-widgets-header__title"
+ }, (0,external_wp_i18n_namespaceObject.__)('Widgets')), !isMediumViewport && (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
+ as: "h1",
+ className: "edit-widgets-header__title"
+ }, (0,external_wp_i18n_namespaceObject.__)('Widgets')), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.NavigableToolbar, {
+ className: "edit-widgets-header-toolbar",
+ "aria-label": (0,external_wp_i18n_namespaceObject.__)('Document tools'),
+ shouldUseKeyboardFocusShortcut: !blockToolbarCanBeFocused
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarItem, {
+ ref: inserterButton,
+ as: external_wp_components_namespaceObject.Button,
+ className: "edit-widgets-header-toolbar__inserter-toggle",
+ variant: "primary",
+ isPressed: isInserterOpen,
+ onMouseDown: event => {
+ event.preventDefault();
+ },
+ onClick: handleClick,
+ icon: library_plus
+ /* translators: button label text should, if possible, be under 16
+ characters. */,
+ label: (0,external_wp_i18n_namespaceObject._x)('Toggle block inserter', 'Generic label for block inserter button')
+ }), isMediumViewport && (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(UndoButton, null), (0,external_wp_element_namespaceObject.createElement)(RedoButton, null), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarItem, {
+ as: external_wp_components_namespaceObject.Button,
+ className: "edit-widgets-header-toolbar__list-view-toggle",
+ icon: list_view,
+ isPressed: isListViewOpen
+ /* translators: button label text should, if possible, be under 16 characters. */,
+ label: (0,external_wp_i18n_namespaceObject.__)('List View'),
+ onClick: toggleListView,
+ ref: setListViewToggleElement
+ })))), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-header__actions"
+ }, (0,external_wp_element_namespaceObject.createElement)(save_button, null), (0,external_wp_element_namespaceObject.createElement)(pinned_items.Slot, {
+ scope: "core/edit-widgets"
+ }), (0,external_wp_element_namespaceObject.createElement)(MoreMenu, null))));
+}
+/* harmony default export */ var header = (Header);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/notices/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+function Notices() {
+ const {
+ removeNotice
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
+ const {
+ notices
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ return {
+ notices: select(external_wp_notices_namespaceObject.store).getNotices()
+ };
+ }, []);
+ const dismissibleNotices = notices.filter(({
+ isDismissible,
+ type
+ }) => isDismissible && type === 'default');
+ const nonDismissibleNotices = notices.filter(({
+ isDismissible,
+ type
+ }) => !isDismissible && type === 'default');
+ const snackbarNotices = notices.filter(({
+ type
+ }) => type === 'snackbar');
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.NoticeList, {
+ notices: nonDismissibleNotices,
+ className: "edit-widgets-notices__pinned"
+ }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.NoticeList, {
+ notices: dismissibleNotices,
+ className: "edit-widgets-notices__dismissible",
+ onRemove: removeNotice
+ }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.SnackbarList, {
+ notices: snackbarNotices,
+ className: "edit-widgets-notices__snackbar",
+ onRemove: removeNotice
+ }));
+}
+/* harmony default export */ var notices = (Notices);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/widget-areas-block-editor-content/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function WidgetAreasBlockEditorContent({
+ blockEditorSettings
+}) {
+ const hasThemeStyles = (0,external_wp_data_namespaceObject.useSelect)(select => !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'themeStyles'), []);
+ const styles = (0,external_wp_element_namespaceObject.useMemo)(() => {
+ return hasThemeStyles ? blockEditorSettings.styles : [];
+ }, [blockEditorSettings, hasThemeStyles]);
+ return (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-block-editor"
+ }, (0,external_wp_element_namespaceObject.createElement)(notices, null), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockTools, null, (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts, null), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableEditorStyles, {
+ styles: styles,
+ scope: ".editor-styles-wrapper"
+ }), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockSelectionClearer, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.WritingFlow, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockList, {
+ className: "edit-widgets-main-block-list"
+ })))));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close.js
+
+/**
+ * WordPress dependencies
+ */
+
+const close_close = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+ xmlns: "http://www.w3.org/2000/svg",
+ viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+ d: "M13 11.8l6.1-6.3-1-1-6.1 6.2-6.1-6.2-1 1 6.1 6.3-6.5 6.7 1 1 6.5-6.6 6.5 6.6 1-1z"
+}));
+/* harmony default export */ var library_close = (close_close);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/hooks/use-widget-library-insertion-point.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+const useWidgetLibraryInsertionPoint = () => {
+ const firstRootId = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ // Default to the first widget area
+ const {
+ getEntityRecord
+ } = select(external_wp_coreData_namespaceObject.store);
+ const widgetAreasPost = getEntityRecord(KIND, POST_TYPE, buildWidgetAreasPostId());
+ return widgetAreasPost?.blocks[0]?.clientId;
+ }, []);
+ return (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getBlockRootClientId,
+ getBlockSelectionEnd,
+ getBlockOrder,
+ getBlockIndex
+ } = select(external_wp_blockEditor_namespaceObject.store);
+ const insertionPoint = select(store_store).__experimentalGetInsertionPoint();
+
+ // "Browse all" in the quick inserter will set the rootClientId to the current block.
+ // Otherwise, it will just be undefined, and we'll have to handle it differently below.
+ if (insertionPoint.rootClientId) {
+ return insertionPoint;
+ }
+ const clientId = getBlockSelectionEnd() || firstRootId;
+ const rootClientId = getBlockRootClientId(clientId);
+
+ // If the selected block is at the root level, it's a widget area and
+ // blocks can't be inserted here. Return this block as the root and the
+ // last child clientId indicating insertion at the end.
+ if (clientId && rootClientId === '') {
+ return {
+ rootClientId: clientId,
+ insertionIndex: getBlockOrder(clientId).length
+ };
+ }
+ return {
+ rootClientId,
+ insertionIndex: getBlockIndex(clientId) + 1
+ };
+ }, [firstRootId]);
+};
+/* harmony default export */ var use_widget_library_insertion_point = (useWidgetLibraryInsertionPoint);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/secondary-sidebar/inserter-sidebar.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function InserterSidebar() {
+ const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
+ const {
+ rootClientId,
+ insertionIndex
+ } = use_widget_library_insertion_point();
+ const {
+ setIsInserterOpened
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const closeInserter = (0,external_wp_element_namespaceObject.useCallback)(() => {
+ return setIsInserterOpened(false);
+ }, [setIsInserterOpened]);
+ const TagName = !isMobileViewport ? external_wp_components_namespaceObject.VisuallyHidden : 'div';
+ const [inserterDialogRef, inserterDialogProps] = (0,external_wp_compose_namespaceObject.__experimentalUseDialog)({
+ onClose: closeInserter,
+ focusOnMount: null
+ });
+ const libraryRef = (0,external_wp_element_namespaceObject.useRef)();
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ libraryRef.current.focusSearch();
+ }, []);
+ return (0,external_wp_element_namespaceObject.createElement)("div", {
+ ref: inserterDialogRef,
+ ...inserterDialogProps,
+ className: "edit-widgets-layout__inserter-panel"
+ }, (0,external_wp_element_namespaceObject.createElement)(TagName, {
+ className: "edit-widgets-layout__inserter-panel-header"
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ icon: library_close,
+ onClick: closeInserter,
+ label: (0,external_wp_i18n_namespaceObject.__)('Close block inserter')
+ })), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-layout__inserter-panel-content"
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__experimentalLibrary, {
+ showInserterHelpPanel: true,
+ shouldFocusBlock: isMobileViewport,
+ rootClientId: rootClientId,
+ __experimentalInsertionIndex: insertionIndex,
+ ref: libraryRef
+ })));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/secondary-sidebar/list-view-sidebar.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function ListViewSidebar({
+ listViewToggleElement
+}) {
+ const {
+ setIsListViewOpened
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+
+ // Use internal state instead of a ref to make sure that the component
+ // re-renders when the dropZoneElement updates.
+ const [dropZoneElement, setDropZoneElement] = (0,external_wp_element_namespaceObject.useState)(null);
+ const focusOnMountRef = (0,external_wp_compose_namespaceObject.useFocusOnMount)('firstElement');
+
+ // When closing the list view, focus should return to the toggle button.
+ const closeListView = (0,external_wp_element_namespaceObject.useCallback)(() => {
+ setIsListViewOpened(false);
+ listViewToggleElement?.focus();
+ }, [listViewToggleElement, setIsListViewOpened]);
+ const closeOnEscape = (0,external_wp_element_namespaceObject.useCallback)(event => {
+ if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE && !event.defaultPrevented) {
+ event.preventDefault();
+ closeListView();
+ }
+ }, [closeListView]);
+ return (
+ // eslint-disable-next-line jsx-a11y/no-static-element-interactions
+ (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-editor__list-view-panel",
+ onKeyDown: closeOnEscape
+ }, (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-editor__list-view-panel-header"
+ }, (0,external_wp_element_namespaceObject.createElement)("strong", null, (0,external_wp_i18n_namespaceObject.__)('List View')), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+ icon: close_small,
+ label: (0,external_wp_i18n_namespaceObject.__)('Close'),
+ onClick: closeListView
+ })), (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-editor__list-view-panel-content",
+ ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([focusOnMountRef, setDropZoneElement])
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__experimentalListView, {
+ dropZoneElement: dropZoneElement
+ })))
+ );
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/secondary-sidebar/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function SecondarySidebar({
+ listViewToggleElement
+}) {
+ const {
+ isInserterOpen,
+ isListViewOpen
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ isInserterOpened,
+ isListViewOpened
+ } = select(store_store);
+ return {
+ isInserterOpen: isInserterOpened(),
+ isListViewOpen: isListViewOpened()
+ };
+ }, []);
+ if (isInserterOpen) {
+ return (0,external_wp_element_namespaceObject.createElement)(InserterSidebar, null);
+ }
+ if (isListViewOpen) {
+ return (0,external_wp_element_namespaceObject.createElement)(ListViewSidebar, {
+ listViewToggleElement: listViewToggleElement
+ });
+ }
+ return null;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/layout/interface.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+const interfaceLabels = {
+ /* translators: accessibility text for the widgets screen top bar landmark region. */
+ header: (0,external_wp_i18n_namespaceObject.__)('Widgets top bar'),
+ /* translators: accessibility text for the widgets screen content landmark region. */
+ body: (0,external_wp_i18n_namespaceObject.__)('Widgets and blocks'),
+ /* translators: accessibility text for the widgets screen settings landmark region. */
+ sidebar: (0,external_wp_i18n_namespaceObject.__)('Widgets settings'),
+ /* translators: accessibility text for the widgets screen footer landmark region. */
+ footer: (0,external_wp_i18n_namespaceObject.__)('Widgets footer')
+};
+function Interface({
+ blockEditorSettings
+}) {
+ const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
+ const isHugeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('huge', '>=');
+ const {
+ setIsInserterOpened,
+ setIsListViewOpened,
+ closeGeneralSidebar
+ } = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
+ const {
+ hasBlockBreadCrumbsEnabled,
+ hasSidebarEnabled,
+ isInserterOpened,
+ isListViewOpened,
+ previousShortcut,
+ nextShortcut
+ } = (0,external_wp_data_namespaceObject.useSelect)(select => ({
+ hasSidebarEnabled: !!select(store).getActiveComplementaryArea(store_store.name),
+ isInserterOpened: !!select(store_store).isInserterOpened(),
+ isListViewOpened: !!select(store_store).isListViewOpened(),
+ hasBlockBreadCrumbsEnabled: !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'showBlockBreadcrumbs'),
+ previousShortcut: select(external_wp_keyboardShortcuts_namespaceObject.store).getAllShortcutKeyCombinations('core/edit-widgets/previous-region'),
+ nextShortcut: select(external_wp_keyboardShortcuts_namespaceObject.store).getAllShortcutKeyCombinations('core/edit-widgets/next-region')
+ }), []);
+ const [listViewToggleElement, setListViewToggleElement] = (0,external_wp_element_namespaceObject.useState)(null);
+
+ // Inserter and Sidebars are mutually exclusive
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ if (hasSidebarEnabled && !isHugeViewport) {
+ setIsInserterOpened(false);
+ setIsListViewOpened(false);
+ }
+ }, [hasSidebarEnabled, isHugeViewport]);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ if ((isInserterOpened || isListViewOpened) && !isHugeViewport) {
+ closeGeneralSidebar();
+ }
+ }, [isInserterOpened, isListViewOpened, isHugeViewport]);
+ const secondarySidebarLabel = isListViewOpened ? (0,external_wp_i18n_namespaceObject.__)('List View') : (0,external_wp_i18n_namespaceObject.__)('Block Library');
+ const hasSecondarySidebar = isListViewOpened || isInserterOpened;
+ return (0,external_wp_element_namespaceObject.createElement)(interface_skeleton, {
+ labels: {
+ ...interfaceLabels,
+ secondarySidebar: secondarySidebarLabel
+ },
+ header: (0,external_wp_element_namespaceObject.createElement)(header, {
+ setListViewToggleElement: setListViewToggleElement
+ }),
+ secondarySidebar: hasSecondarySidebar && (0,external_wp_element_namespaceObject.createElement)(SecondarySidebar, {
+ listViewToggleElement: listViewToggleElement
+ }),
+ sidebar: hasSidebarEnabled && (0,external_wp_element_namespaceObject.createElement)(complementary_area.Slot, {
+ scope: "core/edit-widgets"
+ }),
+ content: (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(WidgetAreasBlockEditorContent, {
+ blockEditorSettings: blockEditorSettings
+ })),
+ footer: hasBlockBreadCrumbsEnabled && !isMobileViewport && (0,external_wp_element_namespaceObject.createElement)("div", {
+ className: "edit-widgets-layout__footer"
+ }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockBreadcrumb, {
+ rootLabelText: (0,external_wp_i18n_namespaceObject.__)('Widgets')
+ })),
+ shortcuts: {
+ previous: previousShortcut,
+ next: nextShortcut
+ }
+ });
+}
+/* harmony default export */ var layout_interface = (Interface);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/layout/unsaved-changes-warning.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+/**
+ * Warns the user if there are unsaved changes before leaving the editor.
+ *
+ * This is a duplicate of the component implemented in the editor package.
+ * Duplicated here as edit-widgets doesn't depend on editor.
+ *
+ * @return {WPComponent} The component.
+ */
+function UnsavedChangesWarning() {
+ const isDirty = (0,external_wp_data_namespaceObject.useSelect)(select => {
+ const {
+ getEditedWidgetAreas
+ } = select(store_store);
+ const editedWidgetAreas = getEditedWidgetAreas();
+ return editedWidgetAreas?.length > 0;
+ }, []);
+ (0,external_wp_element_namespaceObject.useEffect)(() => {
+ /**
+ * Warns the user if there are unsaved changes before leaving the editor.
+ *
+ * @param {Event} event `beforeunload` event.
+ *
+ * @return {string | undefined} Warning prompt message, if unsaved changes exist.
+ */
+ const warnIfUnsavedChanges = event => {
+ if (isDirty) {
+ event.returnValue = (0,external_wp_i18n_namespaceObject.__)('You have unsaved changes. If you proceed, they will be lost.');
+ return event.returnValue;
+ }
+ };
+ window.addEventListener('beforeunload', warnIfUnsavedChanges);
+ return () => {
+ window.removeEventListener('beforeunload', warnIfUnsavedChanges);
+ };
+ }, [isDirty]);
+ return null;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/welcome-guide/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function WelcomeGuide() {
+ var _widgetAreas$filter$l;
+ const isActive = (0,external_wp_data_namespaceObject.useSelect)(select => !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'welcomeGuide'), []);
+ const {
+ toggle
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
+ const widgetAreas = (0,external_wp_data_namespaceObject.useSelect)(select => select(store_store).getWidgetAreas({
+ per_page: -1
+ }), []);
+ if (!isActive) {
+ return null;
+ }
+ const isEntirelyBlockWidgets = widgetAreas?.every(widgetArea => widgetArea.id === 'wp_inactive_widgets' || widgetArea.widgets.every(widgetId => widgetId.startsWith('block-')));
+ const numWidgetAreas = (_widgetAreas$filter$l = widgetAreas?.filter(widgetArea => widgetArea.id !== 'wp_inactive_widgets').length) !== null && _widgetAreas$filter$l !== void 0 ? _widgetAreas$filter$l : 0;
+ return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Guide, {
+ className: "edit-widgets-welcome-guide",
+ contentLabel: (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets'),
+ finishButtonText: (0,external_wp_i18n_namespaceObject.__)('Get started'),
+ onFinish: () => toggle('core/edit-widgets', 'welcomeGuide'),
+ pages: [{
+ image: (0,external_wp_element_namespaceObject.createElement)(WelcomeGuideImage, {
+ nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-canvas.svg",
+ animatedSrc: "https://s.w.org/images/block-editor/welcome-canvas.gif"
+ }),
+ content: (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("h1", {
+ className: "edit-widgets-welcome-guide__heading"
+ }, (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets')), isEntirelyBlockWidgets ? (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_i18n_namespaceObject.sprintf)(
+ // Translators: %s: Number of block areas in the current theme.
+ (0,external_wp_i18n_namespaceObject._n)('Your theme provides %s “block” area for you to add and edit content. Try adding a search bar, social icons, or other types of blocks here and see how they’ll look on your site.', 'Your theme provides %s different “block” areas for you to add and edit content. Try adding a search bar, social icons, or other types of blocks here and see how they’ll look on your site.', numWidgetAreas), numWidgetAreas))) : (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_i18n_namespaceObject.__)('You can now add any block to your site’s widget areas. Don’t worry, all of your favorite widgets still work flawlessly.')), (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_element_namespaceObject.createElement)("strong", null, (0,external_wp_i18n_namespaceObject.__)('Want to stick with the old widgets?')), ' ', (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
+ href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/plugins/classic-widgets/')
+ }, (0,external_wp_i18n_namespaceObject.__)('Get the Classic Widgets plugin.')))))
+ }, {
+ image: (0,external_wp_element_namespaceObject.createElement)(WelcomeGuideImage, {
+ nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-editor.svg",
+ animatedSrc: "https://s.w.org/images/block-editor/welcome-editor.gif"
+ }),
+ content: (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("h1", {
+ className: "edit-widgets-welcome-guide__heading"
+ }, (0,external_wp_i18n_namespaceObject.__)('Make each block your own')), (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_i18n_namespaceObject.__)('Each block comes with its own set of controls for changing things like color, width, and alignment. These will show and hide automatically when you have a block selected.')))
+ }, {
+ image: (0,external_wp_element_namespaceObject.createElement)(WelcomeGuideImage, {
+ nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-library.svg",
+ animatedSrc: "https://s.w.org/images/block-editor/welcome-library.gif"
+ }),
+ content: (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("h1", {
+ className: "edit-widgets-welcome-guide__heading"
+ }, (0,external_wp_i18n_namespaceObject.__)('Get to know the block library')), (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('All of the blocks available to you live in the block library. You’ll find it wherever you see the <InserterIconImage /> icon.'), {
+ InserterIconImage: (0,external_wp_element_namespaceObject.createElement)("img", {
+ className: "edit-widgets-welcome-guide__inserter-icon",
+ alt: (0,external_wp_i18n_namespaceObject.__)('inserter'),
+ src: "data:image/svg+xml,%3Csvg width='18' height='18' viewBox='0 0 18 18' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Crect width='18' height='18' rx='2' fill='%231E1E1E'/%3E%3Cpath d='M9.22727 4V14M4 8.77273H14' stroke='white' stroke-width='1.5'/%3E%3C/svg%3E%0A"
+ })
+ })))
+ }, {
+ image: (0,external_wp_element_namespaceObject.createElement)(WelcomeGuideImage, {
+ nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-documentation.svg",
+ animatedSrc: "https://s.w.org/images/block-editor/welcome-documentation.gif"
+ }),
+ content: (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("h1", {
+ className: "edit-widgets-welcome-guide__heading"
+ }, (0,external_wp_i18n_namespaceObject.__)('Learn how to use the block editor')), (0,external_wp_element_namespaceObject.createElement)("p", {
+ className: "edit-widgets-welcome-guide__text"
+ }, (0,external_wp_i18n_namespaceObject.__)('New to the block editor? Want to learn more about using it? '), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
+ href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/wordpress-block-editor/')
+ }, (0,external_wp_i18n_namespaceObject.__)("Here's a detailed guide."))))
+ }]
+ });
+}
+function WelcomeGuideImage({
+ nonAnimatedSrc,
+ animatedSrc
+}) {
+ return (0,external_wp_element_namespaceObject.createElement)("picture", {
+ className: "edit-widgets-welcome-guide__image"
+ }, (0,external_wp_element_namespaceObject.createElement)("source", {
+ srcSet: nonAnimatedSrc,
+ media: "(prefers-reduced-motion: reduce)"
+ }), (0,external_wp_element_namespaceObject.createElement)("img", {
+ src: animatedSrc,
+ width: "312",
+ height: "240",
+ alt: ""
+ }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/layout/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+function Layout({
+ blockEditorSettings
+}) {
+ const {
+ createErrorNotice
+ } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
+ function onPluginAreaError(name) {
+ createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: plugin name */
+ (0,external_wp_i18n_namespaceObject.__)('The "%s" plugin has encountered an error and cannot be rendered.'), name));
+ }
+ return (0,external_wp_element_namespaceObject.createElement)(ErrorBoundary, null, (0,external_wp_element_namespaceObject.createElement)(WidgetAreasBlockEditorProvider, {
+ blockEditorSettings: blockEditorSettings
+ }, (0,external_wp_element_namespaceObject.createElement)(layout_interface, {
+ blockEditorSettings: blockEditorSettings
+ }), (0,external_wp_element_namespaceObject.createElement)(Sidebar, null), (0,external_wp_element_namespaceObject.createElement)(external_wp_plugins_namespaceObject.PluginArea, {
+ onError: onPluginAreaError
+ }), (0,external_wp_element_namespaceObject.createElement)(UnsavedChangesWarning, null), (0,external_wp_element_namespaceObject.createElement)(WelcomeGuide, null)));
+}
+/* harmony default export */ var layout = (Layout);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+const disabledBlocks = ['core/more', 'core/freeform', 'core/template-part', ...(ALLOW_REUSABLE_BLOCKS ? [] : ['core/block'])];
+
+/**
+ * Initializes the block editor in the widgets screen.
+ *
+ * @param {string} id ID of the root element to render the screen in.
+ * @param {Object} settings Block editor settings.
+ */
+function initializeEditor(id, settings) {
+ const target = document.getElementById(id);
+ const root = (0,external_wp_element_namespaceObject.createRoot)(target);
+ const coreBlocks = (0,external_wp_blockLibrary_namespaceObject.__experimentalGetCoreBlocks)().filter(block => {
+ return !(disabledBlocks.includes(block.name) || block.name.startsWith('core/post') || block.name.startsWith('core/query') || block.name.startsWith('core/site') || block.name.startsWith('core/navigation'));
+ });
+ (0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults('core/edit-widgets', {
+ fixedToolbar: false,
+ welcomeGuide: true,
+ showBlockBreadcrumbs: true,
+ themeStyles: true
+ });
+ (0,external_wp_data_namespaceObject.dispatch)(external_wp_blocks_namespaceObject.store).reapplyBlockTypeFilters();
+ (0,external_wp_blockLibrary_namespaceObject.registerCoreBlocks)(coreBlocks);
+ (0,external_wp_widgets_namespaceObject.registerLegacyWidgetBlock)();
+ if (false) {}
+ (0,external_wp_widgets_namespaceObject.registerLegacyWidgetVariations)(settings);
+ registerBlock(widget_area_namespaceObject);
+ (0,external_wp_widgets_namespaceObject.registerWidgetGroupBlock)();
+ settings.__experimentalFetchLinkSuggestions = (search, searchOptions) => (0,external_wp_coreData_namespaceObject.__experimentalFetchLinkSuggestions)(search, searchOptions, settings);
+
+ // As we are unregistering `core/freeform` to avoid the Classic block, we must
+ // replace it with something as the default freeform content handler. Failure to
+ // do this will result in errors in the default block parser.
+ // see: https://github.com/WordPress/gutenberg/issues/33097
+ (0,external_wp_blocks_namespaceObject.setFreeformContentHandlerName)('core/html');
+ root.render((0,external_wp_element_namespaceObject.createElement)(layout, {
+ blockEditorSettings: settings
+ }));
+ return root;
+}
+
+/**
+ * Compatibility export under the old `initialize` name.
+ */
+const initialize = initializeEditor;
+function reinitializeEditor() {
+ external_wp_deprecated_default()('wp.editWidgets.reinitializeEditor', {
+ since: '6.2',
+ version: '6.3'
+ });
+}
+
+/**
+ * Function to register an individual block.
+ *
+ * @param {Object} block The block to be registered.
+ */
+const registerBlock = block => {
+ if (!block) {
+ return;
+ }
+ const {
+ metadata,
+ settings,
+ name
+ } = block;
+ if (metadata) {
+ (0,external_wp_blocks_namespaceObject.unstable__bootstrapServerSideBlockDefinitions)({
+ [name]: metadata
+ });
+ }
+ (0,external_wp_blocks_namespaceObject.registerBlockType)(name, settings);
+};
+
+
+}();
+(window.wp = window.wp || {}).editWidgets = __webpack_exports__;
+/******/ })()
+; \ No newline at end of file