Upstream/WordPress
1
0
Fork 0
mirror of https://github.com/WordPress/WordPress.git synced 2024-11-08 20:01:12 +01:00
Code Issues Projects Releases Wiki Activity
181e799593
WordPress/wp-includes/js/dist/edit-widgets.js
desrosj d4a8067885 Build/Test Tools: Update several dependencies. 
This updates the following dependencies:
- `@pmmmwh/react-refresh-webpack-plugin` from `0.5.5` to `0.5.11`.
- `autoprefixer` from `10.4.16` to `10.4.17`.
- `copy-webpack-plugin` from `11.0.0` to `12.0.2`.
- `cssnano` from `6.0.1` to `6.0.3`.
- `dotenv` from `16.3.1` to `16.4.4`.
- `dotenv-expand` from `10.0.0` to `11.0.3`.
- `postcss` from `8.4.31` to `8.4.35`.
- `sass` from `1.69.3` to `1.70.0`.
- `sinon` from `16.0.3` to `16.1.3`.
- `source-map-loader` from `4.0.1` to `5.0.0`.
- `terser-webpack-plugin` from `5.3.9` to `5.3.10`.
- `wait-on` from `7.0.1` to `7.2.0`.
- `webpack` from `5.89.0` to `5.90.2`.

Additionally, `npm audit fix` has been run.

See #59658.
Built from https://develop.svn.wordpress.org/trunk@57635


git-svn-id: http://core.svn.wordpress.org/trunk@57136 1a063a9b-81f0-0310-95a4-ce76da25c4cd
2024-02-15 16:53:15 +00:00

4794 lines
166 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 5755:
/***/ ((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 */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (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 */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (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.
(() => {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
initialize: () => (/* binding */ initialize),
initializeEditor: () => (/* binding */ initializeEditor),
reinitializeEditor: () => (/* binding */ reinitializeEditor),
store: () => (/* 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: () => (closeModal),
disableComplementaryArea: () => (disableComplementaryArea),
enableComplementaryArea: () => (enableComplementaryArea),
openModal: () => (openModal),
pinItem: () => (pinItem),
setDefaultComplementaryArea: () => (setDefaultComplementaryArea),
setFeatureDefaults: () => (setFeatureDefaults),
setFeatureValue: () => (setFeatureValue),
toggleFeature: () => (toggleFeature),
unpinItem: () => (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: () => (getActiveComplementaryArea),
isComplementaryAreaLoading: () => (isComplementaryAreaLoading),
isFeatureActive: () => (isFeatureActive),
isItemPinned: () => (isItemPinned),
isModalActive: () => (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: () => (closeGeneralSidebar),
moveBlockToWidgetArea: () => (moveBlockToWidgetArea),
persistStubPost: () => (persistStubPost),
saveEditedWidgetAreas: () => (saveEditedWidgetAreas),
saveWidgetArea: () => (saveWidgetArea),
saveWidgetAreas: () => (saveWidgetAreas),
setIsInserterOpened: () => (setIsInserterOpened),
setIsListViewOpened: () => (setIsListViewOpened),
setIsWidgetAreaOpen: () => (setIsWidgetAreaOpen),
setWidgetAreasOpenState: () => (setWidgetAreasOpenState),
setWidgetIdForClientId: () => (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: () => (getWidgetAreas),
getWidgets: () => (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: () => (__experimentalGetInsertionPoint),
canInsertBlockInWidgetArea: () => (canInsertBlockInWidgetArea),
getEditedWidgetAreas: () => (getEditedWidgetAreas),
getIsWidgetAreaOpen: () => (getIsWidgetAreaOpen),
getParentWidgetAreaBlock: () => (getParentWidgetAreaBlock),
getReferenceWidgetBlocks: () => (getReferenceWidgetBlocks),
getWidget: () => (getWidget),
getWidgetAreaForWidgetId: () => (getWidgetAreaForWidgetId),
getWidgetAreas: () => (selectors_getWidgetAreas),
getWidgets: () => (selectors_getWidgets),
isInserterOpened: () => (isInserterOpened),
isListViewOpened: () => (isListViewOpened),
isSavingWidgetAreas: () => (isSavingWidgetAreas)
});
// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-widgets/build-module/store/private-selectors.js
var private_selectors_namespaceObject = {};
__webpack_require__.r(private_selectors_namespaceObject);
__webpack_require__.d(private_selectors_namespaceObject, {
getListViewToggleRef: () => (getListViewToggleRef)
});
// 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: () => (metadata),
name: () => (widget_area_name),
settings: () => (settings)
});
;// CONCATENATED MODULE: external "React"
const external_React_namespaceObject = window["React"];
;// CONCATENATED MODULE: external ["wp","blocks"]
const external_wp_blocks_namespaceObject = window["wp"]["blocks"];
;// CONCATENATED MODULE: external ["wp","data"]
const external_wp_data_namespaceObject = window["wp"]["data"];
;// CONCATENATED MODULE: external ["wp","deprecated"]
const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
;// CONCATENATED MODULE: external ["wp","element"]
const external_wp_element_namespaceObject = window["wp"]["element"];
;// CONCATENATED MODULE: external ["wp","blockLibrary"]
const external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
;// CONCATENATED MODULE: external ["wp","coreData"]
const external_wp_coreData_namespaceObject = window["wp"]["coreData"];
;// CONCATENATED MODULE: external ["wp","widgets"]
const external_wp_widgets_namespaceObject = window["wp"]["widgets"];
;// CONCATENATED MODULE: external ["wp","preferences"]
const external_wp_preferences_namespaceObject = window["wp"]["preferences"];
;// CONCATENATED MODULE: external ["wp","apiFetch"]
const 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;
}
/**
* This reducer does nothing aside initializing a ref to the list view toggle.
* We will have a unique ref per "editor" instance.
*
* @param {Object} state
* @return {Object} Reference to the list view toggle button.
*/
function listViewToggleRef(state = {
current: null
}) {
return state;
}
/* harmony default export */ const reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
blockInserterPanel,
listViewPanel,
widgetAreasOpenState
}));
;// CONCATENATED MODULE: external ["wp","i18n"]
const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
;// CONCATENATED MODULE: external ["wp","notices"]
const external_wp_notices_namespaceObject = window["wp"]["notices"];
// EXTERNAL MODULE: ./node_modules/classnames/index.js
var classnames = __webpack_require__(5755);
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
;// CONCATENATED MODULE: external ["wp","components"]
const external_wp_components_namespaceObject = window["wp"]["components"];
;// CONCATENATED MODULE: external ["wp","primitives"]
const external_wp_primitives_namespaceObject = window["wp"]["primitives"];
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/check.js
/**
* WordPress dependencies
*/
const check = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const library_check = (check);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/star-filled.js
/**
* WordPress dependencies
*/
const starFilled = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const star_filled = (starFilled);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/star-empty.js
/**
* WordPress dependencies
*/
const starEmpty = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const star_empty = (starEmpty);
;// CONCATENATED MODULE: external ["wp","viewport"]
const 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_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const 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 */ const 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"]
const 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 */ const 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_React_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 */ const 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_React_namespaceObject.createElement)(complementary_area_toggle, {
icon: close_small,
...toggleButtonProps
});
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
className: "components-panel__header interface-complementary-area-header__small"
}, smallScreenTitle && (0,external_React_namespaceObject.createElement)("span", {
className: "interface-complementary-area-header__small-title"
}, smallScreenTitle), toggleButton), (0,external_React_namespaceObject.createElement)("div", {
className: classnames_default()('components-panel__header', 'interface-complementary-area-header', className),
tabIndex: -1
}, children, toggleButton));
};
/* harmony default export */ const 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_React_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_React_namespaceObject.createElement)(Component, {
...props
}, children);
});
}
function ActionItem({
name,
as: Component = external_wp_components_namespaceObject.Button,
onClick,
...props
}) {
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
name: name
}, ({
onClick: fpOnClick
}) => {
return (0,external_React_namespaceObject.createElement)(Component, {
onClick: onClick || fpOnClick ? (...args) => {
(onClick || noop)(...args);
(fpOnClick || noop)(...args);
} : undefined,
...props
});
});
}
ActionItem.Slot = ActionItemSlot;
/* harmony default export */ const 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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
...restProps
});
function ComplementaryAreaMoreMenuItem({
scope,
target,
__unstableExplicitMenuItem,
...props
}) {
return (0,external_React_namespaceObject.createElement)(complementary_area_toggle, {
as: toggleProps => {
return (0,external_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
name: `PinnedItems/${scope}`,
...props
});
}
function PinnedItemsSlot({
scope,
className,
...props
}) {
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Slot, {
name: `PinnedItems/${scope}`,
...props
}, fills => fills?.length > 0 && (0,external_React_namespaceObject.createElement)("div", {
className: classnames_default()(className, 'interface-pinned-items')
}, fills));
}
PinnedItems.Slot = PinnedItemsSlot;
/* harmony default export */ const 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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Slot, {
name: `ComplementaryArea/${scope}`,
...props
});
}
function ComplementaryAreaFill({
scope,
children,
className,
id
}) {
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Fill, {
name: `ComplementaryArea/${scope}`
}, (0,external_React_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
}) {
const {
isLoading,
isActive,
isPinned,
activeArea,
isSmall,
isLarge,
showIconLabels
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
const {
getActiveComplementaryArea,
isComplementaryAreaLoading,
isItemPinned
} = select(store);
const {
get
} = select(external_wp_preferences_namespaceObject.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'),
showIconLabels: get('core', 'showIconLabels')
};
}, [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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, isPinnable && (0,external_React_namespaceObject.createElement)(pinned_items, {
scope: scope
}, isPinned && (0,external_React_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,
size: "compact"
})), name && isPinnable && (0,external_React_namespaceObject.createElement)(ComplementaryAreaMoreMenuItem, {
target: name,
scope: scope,
icon: icon
}, title), isActive && (0,external_React_namespaceObject.createElement)(ComplementaryAreaFill, {
className: classnames_default()('interface-complementary-area', className),
scope: scope,
id: identifier.replace('/', ':')
}, (0,external_React_namespaceObject.createElement)(complementary_area_header, {
className: headerClassName,
closeLabel: closeLabel,
onClose: () => disableComplementaryArea(scope),
smallScreenTitle: smallScreenTitle,
toggleButtonProps: {
label: closeLabel,
shortcut: toggleShortcut,
scope,
identifier
}
}, header || (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("strong", null, title), isPinnable && (0,external_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Panel, {
className: panelClassName
}, children)));
}
const ComplementaryAreaWrapped = complementary_area_context(ComplementaryArea);
ComplementaryAreaWrapped.Slot = ComplementaryAreaSlot;
/* harmony default export */ const complementary_area = (ComplementaryAreaWrapped);
;// CONCATENATED MODULE: external ["wp","compose"]
const 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_React_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,
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._x)('Header', 'header landmark area'),
/* 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_React_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_React_namespaceObject.createElement)("div", {
className: "interface-interface-skeleton__editor"
}, !!header && (0,external_React_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_React_namespaceObject.createElement)("div", {
className: "interface-interface-skeleton__header"
}, editorNotices), (0,external_React_namespaceObject.createElement)("div", {
className: "interface-interface-skeleton__body"
}, !!secondarySidebar && (0,external_React_namespaceObject.createElement)(NavigableRegion, {
className: "interface-interface-skeleton__secondary-sidebar",
ariaLabel: mergedLabels.secondarySidebar
}, secondarySidebar), !!notices && (0,external_React_namespaceObject.createElement)("div", {
className: "interface-interface-skeleton__notices"
}, notices), (0,external_React_namespaceObject.createElement)(NavigableRegion, {
className: "interface-interface-skeleton__content",
ariaLabel: mergedLabels.body
}, content), !!sidebar && (0,external_React_namespaceObject.createElement)(NavigableRegion, {
className: "interface-interface-skeleton__sidebar",
ariaLabel: mergedLabels.sidebar
}, sidebar), !!actions && (0,external_React_namespaceObject.createElement)(NavigableRegion, {
className: "interface-interface-skeleton__actions",
ariaLabel: mergedLabels.actions
}, actions))), !!footer && (0,external_React_namespaceObject.createElement)(NavigableRegion, {
className: "interface-interface-skeleton__footer",
ariaLabel: mergedLabels.footer
}, footer));
}
/* harmony default export */ const 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_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
}));
/* harmony default export */ const 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_React_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,
size: 'compact'
}
}, 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"]
const 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/private-selectors.js
function getListViewToggleRef(state) {
return state.listViewToggleRef;
}
;// CONCATENATED MODULE: external ["wp","privateApis"]
const 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/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);
});
unlock(store_store).registerPrivateSelectors(private_selectors_namespaceObject);
;// CONCATENATED MODULE: external ["wp","hooks"]
const 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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(BlockEdit, {
...props
}), isMoveToWidgetAreaVisible && (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockControls, null, (0,external_React_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"]
const 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 */ const 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_React_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_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Panel, {
className: className,
ref: wrapper
}, (0,external_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.__unstableDisclosureContent, {
className: "wp-block-widget-area__panel-body-content",
visible: opened
}, (0,external_React_namespaceObject.createElement)(external_wp_coreData_namespaceObject.EntityProvider, {
kind: "root",
type: "postType",
id: `widget-area-${id}`
}, (0,external_React_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 = {
$schema: "https://schemas.wp.org/trunk/block.json",
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
variant: "secondary",
ref: ref
}, children);
}
function ErrorBoundaryWarning({
message,
error
}) {
const actions = [(0,external_React_namespaceObject.createElement)(CopyButton, {
key: "copy-error",
text: error.stack
}, (0,external_wp_i18n_namespaceObject.__)('Copy Error'))];
return (0,external_React_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_React_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"]
const external_wp_patterns_namespaceObject = window["wp"]["patterns"];
;// CONCATENATED MODULE: external ["wp","keyboardShortcuts"]
const external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
;// CONCATENATED MODULE: external ["wp","keycodes"]
const 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 */ const 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 */ const 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: ./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 isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium');
const {
reusableBlocks,
isFixedToolbarActive,
keepCaretInsideBlock,
pageOnFront,
pageForPosts
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
const {
canUser,
getEntityRecord,
getEntityRecords
} = select(external_wp_coreData_namespaceObject.store);
const siteSettings = canUser('read', 'settings') ? getEntityRecord('root', 'site') : undefined;
return {
widgetAreas: select(store_store).getWidgetAreas(),
widgets: select(store_store).getWidgets(),
reusableBlocks: ALLOW_REUSABLE_BLOCKS ? 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'),
pageOnFront: siteSettings?.page_on_front,
pageForPosts: siteSettings?.page_for_posts
};
}, []);
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 || !isLargeViewport,
keepCaretInsideBlock,
mediaUpload: mediaUploadBlockEditor,
templateLock: 'all',
__experimentalSetIsInserterOpened: setIsInserterOpened,
pageOnFront,
pageForPosts
};
}, [blockEditorSettings, isFixedToolbarActive, isLargeViewport, keepCaretInsideBlock, mediaPermissions.canCreate, reusableBlocks, setIsInserterOpened, pageOnFront, pageForPosts]);
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.SlotFillProvider, null, (0,external_React_namespaceObject.createElement)(keyboard_shortcuts.Register, null), (0,external_React_namespaceObject.createElement)(ExperimentalBlockEditorProvider, {
value: blocks,
onInput: onInput,
onChange: onChange,
settings: settings,
useSubRegistry: false,
...props
}, children, (0,external_React_namespaceObject.createElement)(PatternsMenuItems, {
rootClientId: widgetAreaId
})));
}
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/drawer-left.js
/**
* WordPress dependencies
*/
const drawerLeft = (0,external_React_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_React_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 */ const drawer_left = (drawerLeft);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/drawer-right.js
/**
* WordPress dependencies
*/
const drawerRight = (0,external_React_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_React_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 */ const drawer_right = (drawerRight);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/block-default.js
/**
* WordPress dependencies
*/
const blockDefault = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const block_default = (blockDefault);
;// CONCATENATED MODULE: external ["wp","url"]
const external_wp_url_namespaceObject = window["wp"]["url"];
;// CONCATENATED MODULE: external ["wp","dom"]
const 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_React_namespaceObject.createElement)("div", {
className: "edit-widgets-widget-areas"
}, (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-widget-areas__top-container"
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockIcon, {
icon: block_default
}), (0,external_React_namespaceObject.createElement)("div", null, (0,external_React_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_React_namespaceObject.createElement)("p", null, (0,external_wp_i18n_namespaceObject.__)('Your theme does not contain any Widget Areas.')), !selectedWidgetArea && (0,external_React_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
/**
* 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
*/
const {
Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);
function SidebarHeader({
selectedWidgetAreaBlock
}) {
return (0,external_React_namespaceObject.createElement)(Tabs.TabList, null, (0,external_React_namespaceObject.createElement)(Tabs.Tab, {
tabId: WIDGET_AREAS_IDENTIFIER
}, selectedWidgetAreaBlock ? selectedWidgetAreaBlock.attributes.name : (0,external_wp_i18n_namespaceObject.__)('Widget Areas')), (0,external_React_namespaceObject.createElement)(Tabs.Tab, {
tabId: BLOCK_INSPECTOR_IDENTIFIER
}, (0,external_wp_i18n_namespaceObject.__)('Block')));
}
function SidebarContent({
hasSelectedNonAreaBlock,
currentArea,
isGeneralSidebarOpen,
selectedWidgetAreaBlock
}) {
const {
enableComplementaryArea
} = (0,external_wp_data_namespaceObject.useDispatch)(store);
(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);
}
// We're intentionally leaving `currentArea` and `isGeneralSidebarOpen`
// out of the dep array because we want this effect to run based on
// block selection changes, not sidebar state changes.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [hasSelectedNonAreaBlock, enableComplementaryArea]);
const tabsContextValue = (0,external_wp_element_namespaceObject.useContext)(Tabs.Context);
return (0,external_React_namespaceObject.createElement)(complementary_area, {
className: "edit-widgets-sidebar",
header: (0,external_React_namespaceObject.createElement)(Tabs.Context.Provider, {
value: tabsContextValue
}, (0,external_React_namespaceObject.createElement)(SidebarHeader, {
selectedWidgetAreaBlock: selectedWidgetAreaBlock
})),
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
}, (0,external_React_namespaceObject.createElement)(Tabs.Context.Provider, {
value: tabsContextValue
}, (0,external_React_namespaceObject.createElement)(Tabs.TabPanel, {
tabId: WIDGET_AREAS_IDENTIFIER,
focusable: false
}, (0,external_React_namespaceObject.createElement)(WidgetAreas, {
selectedWidgetAreaId: selectedWidgetAreaBlock?.attributes.id
})), (0,external_React_namespaceObject.createElement)(Tabs.TabPanel, {
tabId: BLOCK_INSPECTOR_IDENTIFIER,
focusable: false
}, hasSelectedNonAreaBlock ? (0,external_React_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_React_namespaceObject.createElement)("span", {
className: "block-editor-block-inspector__no-blocks"
}, (0,external_wp_i18n_namespaceObject.__)('No block selected.')))));
}
function Sidebar() {
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
};
}, []);
const {
enableComplementaryArea
} = (0,external_wp_data_namespaceObject.useDispatch)(store);
// `newSelectedTabId` could technically be falsey if no tab is selected (i.e.
// the initial render) or when we don't want a tab displayed (i.e. the
// sidebar is closed). These cases should both be covered by the `!!` check
// below, so we shouldn't need any additional falsey handling.
const onTabSelect = (0,external_wp_element_namespaceObject.useCallback)(newSelectedTabId => {
if (!!newSelectedTabId) {
enableComplementaryArea(store_store.name, newSelectedTabId);
}
}, [enableComplementaryArea]);
return (0,external_React_namespaceObject.createElement)(Tabs
// Due to how this component is controlled (via a value from the
// `interfaceStore`), when the sidebar closes the currently selected
// tab can't be found. This causes the component to continuously reset
// the selection to `null` in an infinite loop. Proactively setting
// the selected tab to `null` avoids that.
, {
selectedTabId: isGeneralSidebarOpen ? currentArea : null,
onSelect: onTabSelect,
selectOnMove: false
}, (0,external_React_namespaceObject.createElement)(SidebarContent, {
hasSelectedNonAreaBlock: hasSelectedNonAreaBlock,
currentArea: currentArea,
isGeneralSidebarOpen: isGeneralSidebarOpen,
selectedWidgetAreaBlock: selectedWidgetAreaBlock
}));
}
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plus.js
/**
* WordPress dependencies
*/
const plus = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z"
}));
/* harmony default export */ const library_plus = (plus);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/list-view.js
/**
* WordPress dependencies
*/
const listView = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
viewBox: "0 0 24 24",
xmlns: "http://www.w3.org/2000/svg"
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
d: "M3 6h11v1.5H3V6Zm3.5 5.5h11V13h-11v-1.5ZM21 17H10v1.5h11V17Z"
}));
/* harmony default export */ const list_view = (listView);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/undo.js
/**
* WordPress dependencies
*/
const undo = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const library_undo = (undo);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/redo.js
/**
* WordPress dependencies
*/
const redo = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const library_redo = (redo);
;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/undo-redo/undo.js
/**
* WordPress dependencies
*/
function UndoButton(props, ref) {
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
...props,
ref: ref,
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
});
}
/* harmony default export */ const undo_redo_undo = ((0,external_wp_element_namespaceObject.forwardRef)(UndoButton));
;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/undo-redo/redo.js
/**
* WordPress dependencies
*/
function RedoButton(props, ref) {
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
...props,
ref: ref,
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
});
}
/* harmony default export */ const undo_redo_redo = ((0,external_wp_element_namespaceObject.forwardRef)(RedoButton));
;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/document-tools/index.js
/**
* WordPress dependencies
*/
/**
* Internal dependencies
*/
const {
useCanBlockToolbarBeFocused
} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
function DocumentTools() {
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,
listViewToggleRef
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
const {
isInserterOpened,
isListViewOpened,
getListViewToggleRef
} = unlock(select(store_store));
return {
isInserterOpen: isInserterOpened(),
isListViewOpen: isListViewOpened(),
listViewToggleRef: getListViewToggleRef()
};
}, []);
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]);
// If there's a block toolbar to be focused, disable the focus shortcut for the document toolbar.
const blockToolbarCanBeFocused = useCanBlockToolbarBeFocused();
return (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.NavigableToolbar, {
className: "edit-widgets-header-toolbar",
"aria-label": (0,external_wp_i18n_namespaceObject.__)('Document tools'),
shouldUseKeyboardFocusShortcut: !blockToolbarCanBeFocused,
variant: "unstyled"
}, (0,external_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarItem, {
as: undo_redo_undo
}), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarItem, {
as: undo_redo_redo
}), (0,external_React_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: listViewToggleRef
})));
}
/* harmony default export */ const document_tools = (DocumentTools);
;// 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);
const isDisabled = isSaving || !hasEditedWidgetAreaIds;
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
variant: "primary",
isBusy: isSaving,
"aria-disabled": isDisabled,
onClick: isDisabled ? undefined : saveEditedWidgetAreas
}, isSaving ? (0,external_wp_i18n_namespaceObject.__)('Saving…') : (0,external_wp_i18n_namespaceObject.__)('Update'));
}
/* harmony default export */ const save_button = (SaveButton);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/external.js
/**
* WordPress dependencies
*/
const external = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const 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_React_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_React_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, {
key: index
}, character);
}
return (0,external_React_namespaceObject.createElement)("kbd", {
key: index,
className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-key"
}, character);
}));
}
function Shortcut({
description,
keyCombination,
aliases = [],
ariaLabel
}) {
return (0,external_React_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-description"
}, description), (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-term"
}, (0,external_React_namespaceObject.createElement)(KeyCombination, {
keyCombination: keyCombination,
forceAriaLabel: ariaLabel
}), aliases.map((alias, index) => (0,external_React_namespaceObject.createElement)(KeyCombination, {
keyCombination: alias,
forceAriaLabel: ariaLabel,
key: index
}))));
}
/* harmony default export */ const 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_React_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
keyCombination: keyCombination,
description: description,
aliases: aliases
});
}
/* harmony default export */ const 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_React_namespaceObject.createElement)("ul", {
className: "edit-widgets-keyboard-shortcut-help-modal__shortcut-list",
role: "list"
}, shortcuts.map((shortcut, index) => (0,external_React_namespaceObject.createElement)("li", {
className: "edit-widgets-keyboard-shortcut-help-modal__shortcut",
key: index
}, typeof shortcut === 'string' ? (0,external_React_namespaceObject.createElement)(dynamic_shortcut, {
name: shortcut
}) : (0,external_React_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
...shortcut
}))))
/* eslint-enable jsx-a11y/no-redundant-roles */;
const ShortcutSection = ({
title,
shortcuts,
className
}) => (0,external_React_namespaceObject.createElement)("section", {
className: classnames_default()('edit-widgets-keyboard-shortcut-help-modal__section', className)
}, !!title && (0,external_React_namespaceObject.createElement)("h2", {
className: "edit-widgets-keyboard-shortcut-help-modal__section-title"
}, title), (0,external_React_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_React_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_React_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_React_namespaceObject.createElement)(ShortcutSection, {
className: "edit-widgets-keyboard-shortcut-help-modal__main-shortcuts",
shortcuts: ['core/edit-widgets/keyboard-shortcuts']
}), (0,external_React_namespaceObject.createElement)(ShortcutCategorySection, {
title: (0,external_wp_i18n_namespaceObject.__)('Global shortcuts'),
categoryName: "global"
}), (0,external_React_namespaceObject.createElement)(ShortcutCategorySection, {
title: (0,external_wp_i18n_namespaceObject.__)('Selection shortcuts'),
categoryName: "selection"
}), (0,external_React_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_React_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_React_namespaceObject.createElement)(Slot, {
fillProps: fillProps
}, fills => fills.length > 0 && fills);
/* harmony default export */ const 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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(MoreMenuDropdown, null, onClose => (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, isLargeViewport && (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
label: (0,external_wp_i18n_namespaceObject._x)('View', 'noun')
}, (0,external_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
label: (0,external_wp_i18n_namespaceObject.__)('Tools')
}, (0,external_React_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_React_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
scope: "core/edit-widgets",
name: "welcomeGuide",
label: (0,external_wp_i18n_namespaceObject.__)('Welcome Guide')
}), (0,external_React_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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
as: "span"
}, /* translators: accessibility text */
(0,external_wp_i18n_namespaceObject.__)('(opens in a new tab)'))), (0,external_React_namespaceObject.createElement)(tools_more_menu_group.Slot, {
fillProps: {
onClose
}
})), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
label: (0,external_wp_i18n_namespaceObject.__)('Preferences')
}, (0,external_React_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_React_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_React_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_React_namespaceObject.createElement)(KeyboardShortcutHelpModal, {
isModalActive: isKeyboardShortcutsModalActive,
toggleModal: toggleKeyboardShortcutsModal
}));
}
;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/header/index.js
/**
* WordPress dependencies
*/
/**
* Internal dependencies
*/
function Header() {
const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium');
const blockToolbarRef = (0,external_wp_element_namespaceObject.useRef)();
const {
hasFixedToolbar
} = (0,external_wp_data_namespaceObject.useSelect)(select => ({
hasFixedToolbar: !!select(external_wp_preferences_namespaceObject.store).get('core/edit-widgets', 'fixedToolbar')
}), []);
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-header"
}, (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-header__navigable-toolbar-wrapper"
}, isLargeViewport && (0,external_React_namespaceObject.createElement)("h1", {
className: "edit-widgets-header__title"
}, (0,external_wp_i18n_namespaceObject.__)('Widgets')), !isLargeViewport && (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
as: "h1",
className: "edit-widgets-header__title"
}, (0,external_wp_i18n_namespaceObject.__)('Widgets')), (0,external_React_namespaceObject.createElement)(document_tools, null), hasFixedToolbar && isLargeViewport && (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
className: "selected-block-tools-wrapper"
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockToolbar, {
hideDragHandle: true
})), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Popover.Slot, {
ref: blockToolbarRef,
name: "block-toolbar"
}))), (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-header__actions"
}, (0,external_React_namespaceObject.createElement)(save_button, null), (0,external_React_namespaceObject.createElement)(pinned_items.Slot, {
scope: "core/edit-widgets"
}), (0,external_React_namespaceObject.createElement)(MoreMenu, null))));
}
/* harmony default export */ const header = (Header);
;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-widgets/build-module/components/notices/index.js
/**
* WordPress dependencies
*/
// Last three notices. Slices from the tail end of the list.
const MAX_VISIBLE_NOTICES = -3;
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').slice(MAX_VISIBLE_NOTICES);
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.NoticeList, {
notices: nonDismissibleNotices,
className: "edit-widgets-notices__pinned"
}), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.NoticeList, {
notices: dismissibleNotices,
className: "edit-widgets-notices__dismissible",
onRemove: removeNotice
}), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.SnackbarList, {
notices: snackbarNotices,
className: "edit-widgets-notices__snackbar",
onRemove: removeNotice
}));
}
/* harmony default export */ const 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 isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium');
const styles = (0,external_wp_element_namespaceObject.useMemo)(() => {
return hasThemeStyles ? blockEditorSettings.styles : [];
}, [blockEditorSettings, hasThemeStyles]);
return (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-block-editor"
}, (0,external_React_namespaceObject.createElement)(notices, null), !isLargeViewport && (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockToolbar, {
hideDragHandle: true
}), (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockTools, null, (0,external_React_namespaceObject.createElement)(keyboard_shortcuts, null), (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableEditorStyles, {
styles: styles,
scope: ".editor-styles-wrapper"
}), (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockSelectionClearer, null, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.WritingFlow, null, (0,external_React_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_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24"
}, (0,external_React_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 */ const 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 */ const 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_React_namespaceObject.createElement)("div", {
ref: inserterDialogRef,
...inserterDialogProps,
className: "edit-widgets-layout__inserter-panel"
}, (0,external_React_namespaceObject.createElement)(TagName, {
className: "edit-widgets-layout__inserter-panel-header"
}, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
icon: library_close,
onClick: closeInserter,
label: (0,external_wp_i18n_namespaceObject.__)('Close block inserter')
})), (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-layout__inserter-panel-content"
}, (0,external_React_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() {
const {
setIsListViewOpened
} = (0,external_wp_data_namespaceObject.useDispatch)(store_store);
const {
getListViewToggleRef
} = unlock((0,external_wp_data_namespaceObject.useSelect)(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);
getListViewToggleRef().current?.focus();
}, [getListViewToggleRef, 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_React_namespaceObject.createElement)("div", {
className: "edit-widgets-editor__list-view-panel",
onKeyDown: closeOnEscape
}, (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-editor__list-view-panel-header"
}, (0,external_React_namespaceObject.createElement)("strong", null, (0,external_wp_i18n_namespaceObject.__)('List View')), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
icon: close_small,
label: (0,external_wp_i18n_namespaceObject.__)('Close'),
onClick: closeListView
})), (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-editor__list-view-panel-content",
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([focusOnMountRef, setDropZoneElement])
}, (0,external_React_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() {
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_React_namespaceObject.createElement)(InserterSidebar, null);
}
if (isListViewOpen) {
return (0,external_React_namespaceObject.createElement)(ListViewSidebar, null);
}
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')
}), []);
// 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_React_namespaceObject.createElement)(interface_skeleton, {
labels: {
...interfaceLabels,
secondarySidebar: secondarySidebarLabel
},
header: (0,external_React_namespaceObject.createElement)(header, null),
secondarySidebar: hasSecondarySidebar && (0,external_React_namespaceObject.createElement)(SecondarySidebar, null),
sidebar: hasSidebarEnabled && (0,external_React_namespaceObject.createElement)(complementary_area.Slot, {
scope: "core/edit-widgets"
}),
content: (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(WidgetAreasBlockEditorContent, {
blockEditorSettings: blockEditorSettings
})),
footer: hasBlockBreadCrumbsEnabled && !isMobileViewport && (0,external_React_namespaceObject.createElement)("div", {
className: "edit-widgets-layout__footer"
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockBreadcrumb, {
rootLabelText: (0,external_wp_i18n_namespaceObject.__)('Widgets')
})),
shortcuts: {
previous: previousShortcut,
next: nextShortcut
}
});
}
/* harmony default export */ const 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 {Component} 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_React_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_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("h1", {
className: "edit-widgets-welcome-guide__heading"
}, (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets')), isEntirelyBlockWidgets ? (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_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_React_namespaceObject.createElement)("p", {
className: "edit-widgets-welcome-guide__text"
}, (0,external_React_namespaceObject.createElement)("strong", null, (0,external_wp_i18n_namespaceObject.__)('Want to stick with the old widgets?')), ' ', (0,external_React_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_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("h1", {
className: "edit-widgets-welcome-guide__heading"
}, (0,external_wp_i18n_namespaceObject.__)('Make each block your own')), (0,external_React_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_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("h1", {
className: "edit-widgets-welcome-guide__heading"
}, (0,external_wp_i18n_namespaceObject.__)('Get to know the block library')), (0,external_React_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_React_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_React_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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("h1", {
className: "edit-widgets-welcome-guide__heading"
}, (0,external_wp_i18n_namespaceObject.__)('Learn how to use the block editor')), (0,external_React_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_React_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_React_namespaceObject.createElement)("picture", {
className: "edit-widgets-welcome-guide__image"
}, (0,external_React_namespaceObject.createElement)("source", {
srcSet: nonAnimatedSrc,
media: "(prefers-reduced-motion: reduce)"
}), (0,external_React_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_React_namespaceObject.createElement)(ErrorBoundary, null, (0,external_React_namespaceObject.createElement)(WidgetAreasBlockEditorProvider, {
blockEditorSettings: blockEditorSettings
}, (0,external_React_namespaceObject.createElement)(layout_interface, {
blockEditorSettings: blockEditorSettings
}), (0,external_React_namespaceObject.createElement)(Sidebar, null), (0,external_React_namespaceObject.createElement)(external_wp_plugins_namespaceObject.PluginArea, {
onError: onPluginAreaError
}), (0,external_React_namespaceObject.createElement)(UnsavedChangesWarning, null), (0,external_React_namespaceObject.createElement)(WelcomeGuide, null)));
}
/* harmony default export */ const 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_React_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__;
/******/ })()
;
Reference in New Issue View Git Blame Copy Permalink