mirror of
https://github.com/WordPress/WordPress.git
synced 2024-11-20 01:25:30 +01:00
ab8a964858
This is the last step of backports from the Gutenberg plugin for WordPress 6.0 Beta 1 release. It includes all updates WordPress packages published to npm based on the Gutenberg plugin v13.0 RC3 release. This patch also includes all the necessary changes applied to core blocks. New blocks included: - Avatar - Comment Author Name - Comment Content - Comment Date - Comment Edit Link - Comment Rely Link - Comment Template - Comments Pagination - Comments Pagination Next - Comments Pagination Previous - Comments Query Loop - Home Link - Post Author Biography - Query No Results - Read More See more details in https://github.com/WordPress/wordpress-develop/pull/2564. Props zieladam, ramonopoly, ocean90. Fixes #55505. Built from https://develop.svn.wordpress.org/trunk@53157 git-svn-id: http://core.svn.wordpress.org/trunk@52746 1a063a9b-81f0-0310-95a4-ce76da25c4cd
3086 lines
102 KiB
JavaScript
3086 lines
102 KiB
JavaScript
/******/ (function() { // webpackBootstrap
|
||
/******/ var __webpack_modules__ = ({
|
||
|
||
/***/ 4403:
|
||
/***/ (function(module, exports) {
|
||
|
||
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
|
||
Copyright (c) 2018 Jed Watson.
|
||
Licensed under the MIT License (MIT), see
|
||
http://jedwatson.github.io/classnames
|
||
*/
|
||
/* global define */
|
||
|
||
(function () {
|
||
'use strict';
|
||
|
||
var hasOwn = {}.hasOwnProperty;
|
||
|
||
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) {
|
||
for (var key in arg) {
|
||
if (hasOwn.call(arg, key) && arg[key]) {
|
||
classes.push(key);
|
||
}
|
||
}
|
||
} else {
|
||
classes.push(arg.toString());
|
||
}
|
||
}
|
||
}
|
||
|
||
return classes.join(' ');
|
||
}
|
||
|
||
if ( true && module.exports) {
|
||
classNames.default = classNames;
|
||
module.exports = classNames;
|
||
} else if (true) {
|
||
// register as 'classnames', consistent with npm package name
|
||
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
|
||
return classNames;
|
||
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
||
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
||
} else {}
|
||
}());
|
||
|
||
|
||
/***/ })
|
||
|
||
/******/ });
|
||
/************************************************************************/
|
||
/******/ // The module cache
|
||
/******/ var __webpack_module_cache__ = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/ // Check if module is in cache
|
||
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
||
/******/ if (cachedModule !== undefined) {
|
||
/******/ return cachedModule.exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = __webpack_module_cache__[moduleId] = {
|
||
/******/ // no module.id needed
|
||
/******/ // no module.loaded needed
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/************************************************************************/
|
||
/******/ /* webpack/runtime/compat get default export */
|
||
/******/ !function() {
|
||
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
/******/ __webpack_require__.n = function(module) {
|
||
/******/ var getter = module && module.__esModule ?
|
||
/******/ function() { return module['default']; } :
|
||
/******/ function() { return module; };
|
||
/******/ __webpack_require__.d(getter, { a: getter });
|
||
/******/ return getter;
|
||
/******/ };
|
||
/******/ }();
|
||
/******/
|
||
/******/ /* webpack/runtime/define property getters */
|
||
/******/ !function() {
|
||
/******/ // define getter functions for harmony exports
|
||
/******/ __webpack_require__.d = function(exports, definition) {
|
||
/******/ for(var key in definition) {
|
||
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
||
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
||
/******/ }
|
||
/******/ }
|
||
/******/ };
|
||
/******/ }();
|
||
/******/
|
||
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
||
/******/ !function() {
|
||
/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
|
||
/******/ }();
|
||
/******/
|
||
/******/ /* webpack/runtime/make namespace object */
|
||
/******/ !function() {
|
||
/******/ // define __esModule on exports
|
||
/******/ __webpack_require__.r = function(exports) {
|
||
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
||
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
||
/******/ }
|
||
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
||
/******/ };
|
||
/******/ }();
|
||
/******/
|
||
/************************************************************************/
|
||
var __webpack_exports__ = {};
|
||
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
|
||
!function() {
|
||
"use strict";
|
||
// ESM COMPAT FLAG
|
||
__webpack_require__.r(__webpack_exports__);
|
||
|
||
// EXPORTS
|
||
__webpack_require__.d(__webpack_exports__, {
|
||
"initialize": function() { return /* binding */ initialize; }
|
||
});
|
||
|
||
// NAMESPACE OBJECT: ./node_modules/@wordpress/customize-widgets/build-module/store/selectors.js
|
||
var selectors_namespaceObject = {};
|
||
__webpack_require__.r(selectors_namespaceObject);
|
||
__webpack_require__.d(selectors_namespaceObject, {
|
||
"__experimentalGetInsertionPoint": function() { return __experimentalGetInsertionPoint; },
|
||
"isInserterOpened": function() { return isInserterOpened; }
|
||
});
|
||
|
||
// NAMESPACE OBJECT: ./node_modules/@wordpress/customize-widgets/build-module/store/actions.js
|
||
var actions_namespaceObject = {};
|
||
__webpack_require__.r(actions_namespaceObject);
|
||
__webpack_require__.d(actions_namespaceObject, {
|
||
"setIsInserterOpened": function() { return setIsInserterOpened; }
|
||
});
|
||
|
||
// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/actions.js
|
||
var store_actions_namespaceObject = {};
|
||
__webpack_require__.r(store_actions_namespaceObject);
|
||
__webpack_require__.d(store_actions_namespaceObject, {
|
||
"disableComplementaryArea": function() { return disableComplementaryArea; },
|
||
"enableComplementaryArea": function() { return enableComplementaryArea; },
|
||
"pinItem": function() { return pinItem; },
|
||
"setFeatureDefaults": function() { return setFeatureDefaults; },
|
||
"setFeatureValue": function() { return setFeatureValue; },
|
||
"toggleFeature": function() { return toggleFeature; },
|
||
"unpinItem": function() { return unpinItem; }
|
||
});
|
||
|
||
// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/selectors.js
|
||
var store_selectors_namespaceObject = {};
|
||
__webpack_require__.r(store_selectors_namespaceObject);
|
||
__webpack_require__.d(store_selectors_namespaceObject, {
|
||
"getActiveComplementaryArea": function() { return getActiveComplementaryArea; },
|
||
"isFeatureActive": function() { return isFeatureActive; },
|
||
"isItemPinned": function() { return isItemPinned; }
|
||
});
|
||
|
||
;// CONCATENATED MODULE: external ["wp","element"]
|
||
var external_wp_element_namespaceObject = window["wp"]["element"];
|
||
;// CONCATENATED MODULE: external ["wp","blockLibrary"]
|
||
var external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
|
||
;// CONCATENATED MODULE: external ["wp","widgets"]
|
||
var external_wp_widgets_namespaceObject = window["wp"]["widgets"];
|
||
;// CONCATENATED MODULE: external ["wp","blocks"]
|
||
var external_wp_blocks_namespaceObject = window["wp"]["blocks"];
|
||
;// CONCATENATED MODULE: external ["wp","data"]
|
||
var external_wp_data_namespaceObject = window["wp"]["data"];
|
||
;// CONCATENATED MODULE: external ["wp","preferences"]
|
||
var external_wp_preferences_namespaceObject = window["wp"]["preferences"];
|
||
;// CONCATENATED MODULE: external ["wp","components"]
|
||
var external_wp_components_namespaceObject = window["wp"]["components"];
|
||
;// CONCATENATED MODULE: external ["wp","keyboardShortcuts"]
|
||
var external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
|
||
;// CONCATENATED MODULE: external ["wp","i18n"]
|
||
var external_wp_i18n_namespaceObject = window["wp"]["i18n"];
|
||
;// CONCATENATED MODULE: external ["wp","blockEditor"]
|
||
var external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
|
||
;// CONCATENATED MODULE: external ["wp","compose"]
|
||
var external_wp_compose_namespaceObject = window["wp"]["compose"];
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/error-boundary/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
function CopyButton(_ref) {
|
||
let {
|
||
text,
|
||
children
|
||
} = _ref;
|
||
const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(text);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
|
||
variant: "secondary",
|
||
ref: ref
|
||
}, children);
|
||
}
|
||
|
||
class ErrorBoundary extends external_wp_element_namespaceObject.Component {
|
||
constructor() {
|
||
super(...arguments);
|
||
this.state = {
|
||
error: null
|
||
};
|
||
}
|
||
|
||
componentDidCatch(error) {
|
||
this.setState({
|
||
error
|
||
});
|
||
}
|
||
|
||
render() {
|
||
const {
|
||
error
|
||
} = this.state;
|
||
|
||
if (!error) {
|
||
return this.props.children;
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.Warning, {
|
||
className: "customize-widgets-error-boundary",
|
||
actions: [(0,external_wp_element_namespaceObject.createElement)(CopyButton, {
|
||
key: "copy-error",
|
||
text: error.stack
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Copy Error'))]
|
||
}, (0,external_wp_i18n_namespaceObject.__)('The editor has encountered an unexpected error.'));
|
||
}
|
||
|
||
}
|
||
|
||
;// CONCATENATED MODULE: external "lodash"
|
||
var external_lodash_namespaceObject = window["lodash"];
|
||
;// CONCATENATED MODULE: external ["wp","coreData"]
|
||
var external_wp_coreData_namespaceObject = window["wp"]["coreData"];
|
||
;// CONCATENATED MODULE: external ["wp","mediaUtils"]
|
||
var external_wp_mediaUtils_namespaceObject = window["wp"]["mediaUtils"];
|
||
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
||
function _extends() {
|
||
_extends = Object.assign || function (target) {
|
||
for (var i = 1; i < arguments.length; i++) {
|
||
var source = arguments[i];
|
||
|
||
for (var key in source) {
|
||
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
return target;
|
||
};
|
||
|
||
return _extends.apply(this, arguments);
|
||
}
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/block-inspector-button/index.js
|
||
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
function BlockInspectorButton(_ref) {
|
||
let {
|
||
inspector,
|
||
closeMenu,
|
||
...props
|
||
} = _ref;
|
||
const selectedBlockClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getSelectedBlockClientId(), []);
|
||
const selectedBlock = (0,external_wp_element_namespaceObject.useMemo)(() => document.getElementById(`block-${selectedBlockClientId}`), [selectedBlockClientId]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, _extends({
|
||
onClick: () => {
|
||
// Open the inspector.
|
||
inspector.open({
|
||
returnFocusWhenClose: selectedBlock
|
||
}); // Then close the dropdown menu.
|
||
|
||
closeMenu();
|
||
}
|
||
}, props), (0,external_wp_i18n_namespaceObject.__)('Show more settings'));
|
||
}
|
||
|
||
/* harmony default export */ var block_inspector_button = (BlockInspectorButton);
|
||
|
||
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
||
var classnames = __webpack_require__(4403);
|
||
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
||
;// CONCATENATED MODULE: external ["wp","keycodes"]
|
||
var external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
|
||
;// CONCATENATED MODULE: external ["wp","primitives"]
|
||
var external_wp_primitives_namespaceObject = window["wp"]["primitives"];
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/undo.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const undo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M18.3 11.7c-.6-.6-1.4-.9-2.3-.9H6.7l2.9-3.3-1.1-1-4.5 5L8.5 16l1-1-2.7-2.7H16c.5 0 .9.2 1.3.5 1 1 1 3.4 1 4.5v.3h1.5v-.2c0-1.5 0-4.3-1.5-5.7z"
|
||
}));
|
||
/* harmony default export */ var library_undo = (undo);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/redo.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const redo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M15.6 6.5l-1.1 1 2.9 3.3H8c-.9 0-1.7.3-2.3.9-1.4 1.5-1.4 4.2-1.4 5.6v.2h1.5v-.3c0-1.1 0-3.5 1-4.5.3-.3.7-.5 1.3-.5h9.2L14.5 15l1.1 1.1 4.6-4.6-4.6-5z"
|
||
}));
|
||
/* harmony default export */ var library_redo = (redo);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plus.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const plus = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M18 11.2h-5.2V6h-1.6v5.2H6v1.6h5.2V18h1.6v-5.2H18z"
|
||
}));
|
||
/* harmony default export */ var library_plus = (plus);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close-small.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const closeSmall = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z"
|
||
}));
|
||
/* harmony default export */ var close_small = (closeSmall);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/reducer.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
/**
|
||
* Reducer tracking whether the inserter is open.
|
||
*
|
||
* @param {boolean|Object} state
|
||
* @param {Object} action
|
||
*/
|
||
|
||
function blockInserterPanel() {
|
||
let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
||
let action = arguments.length > 1 ? arguments[1] : undefined;
|
||
|
||
switch (action.type) {
|
||
case 'SET_IS_INSERTER_OPENED':
|
||
return action.value;
|
||
}
|
||
|
||
return state;
|
||
}
|
||
|
||
/* harmony default export */ var reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
|
||
blockInserterPanel
|
||
}));
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/selectors.js
|
||
/**
|
||
* 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) {
|
||
const {
|
||
rootClientId,
|
||
insertionIndex
|
||
} = state.blockInserterPanel;
|
||
return {
|
||
rootClientId,
|
||
insertionIndex
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/actions.js
|
||
/**
|
||
* 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
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/constants.js
|
||
/**
|
||
* Module Constants
|
||
*/
|
||
const STORE_NAME = 'core/customize-widgets';
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-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#registering-a-store
|
||
*
|
||
* @type {Object}
|
||
*/
|
||
|
||
const storeConfig = {
|
||
reducer: reducer,
|
||
selectors: selectors_namespaceObject,
|
||
actions: 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 = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, storeConfig);
|
||
(0,external_wp_data_namespaceObject.register)(store);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/inserter/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
function Inserter(_ref) {
|
||
let {
|
||
setIsOpened
|
||
} = _ref;
|
||
const inserterTitleId = (0,external_wp_compose_namespaceObject.useInstanceId)(Inserter, 'customize-widget-layout__inserter-panel-title');
|
||
const insertionPoint = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__experimentalGetInsertionPoint(), []);
|
||
return (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-layout__inserter-panel",
|
||
"aria-labelledby": inserterTitleId
|
||
}, (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-layout__inserter-panel-header"
|
||
}, (0,external_wp_element_namespaceObject.createElement)("h2", {
|
||
id: inserterTitleId,
|
||
className: "customize-widgets-layout__inserter-panel-header-title"
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Add a block')), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
|
||
className: "customize-widgets-layout__inserter-panel-header-close-button",
|
||
icon: close_small,
|
||
onClick: () => setIsOpened(false),
|
||
"aria-label": (0,external_wp_i18n_namespaceObject.__)('Close inserter')
|
||
})), (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-layout__inserter-panel-content"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__experimentalLibrary, {
|
||
rootClientId: insertionPoint.rootClientId,
|
||
__experimentalInsertionIndex: insertionPoint.insertionIndex,
|
||
showInserterHelpPanel: true,
|
||
onSelect: () => setIsOpened(false)
|
||
})));
|
||
}
|
||
|
||
/* harmony default export */ var components_inserter = (Inserter);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/external.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const external = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M18.2 17c0 .7-.6 1.2-1.2 1.2H7c-.7 0-1.2-.6-1.2-1.2V7c0-.7.6-1.2 1.2-1.2h3.2V4.2H7C5.5 4.2 4.2 5.5 4.2 7v10c0 1.5 1.2 2.8 2.8 2.8h10c1.5 0 2.8-1.2 2.8-2.8v-3.6h-1.5V17zM14.9 3v1.5h3.7l-6.4 6.4 1.1 1.1 6.4-6.4v3.7h1.5V3h-6.3z"
|
||
}));
|
||
/* harmony default export */ var library_external = (external);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const moreVertical = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
viewBox: "0 0 24 24"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
||
d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
|
||
}));
|
||
/* harmony default export */ var more_vertical = (moreVertical);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/more-menu-dropdown/index.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
function MoreMenuDropdown(_ref) {
|
||
let {
|
||
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
|
||
} = _ref;
|
||
return (0,external_wp_element_namespaceObject.createElement)(DropdownComponent, {
|
||
className: classnames_default()('interface-more-menu-dropdown', className),
|
||
icon: more_vertical,
|
||
label: label,
|
||
popoverProps: {
|
||
position: 'bottom left',
|
||
...popoverProps,
|
||
className: classnames_default()('interface-more-menu-dropdown__content', popoverProps === null || popoverProps === void 0 ? void 0 : popoverProps.className)
|
||
},
|
||
toggleProps: {
|
||
tooltipPosition: 'bottom',
|
||
...toggleProps
|
||
}
|
||
}, onClose => children(onClose));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/index.js
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
;// CONCATENATED MODULE: external ["wp","deprecated"]
|
||
var external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
|
||
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/actions.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* Enable the complementary area.
|
||
*
|
||
* @param {string} scope Complementary area scope.
|
||
* @param {string} area Area identifier.
|
||
*/
|
||
|
||
const enableComplementaryArea = (scope, area) => _ref => {
|
||
let {
|
||
registry
|
||
} = _ref;
|
||
|
||
// Return early if there's no area.
|
||
if (!area) {
|
||
return;
|
||
}
|
||
|
||
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'complementaryArea', area);
|
||
};
|
||
/**
|
||
* Disable the complementary area.
|
||
*
|
||
* @param {string} scope Complementary area scope.
|
||
*/
|
||
|
||
const disableComplementaryArea = scope => _ref2 => {
|
||
let {
|
||
registry
|
||
} = _ref2;
|
||
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'complementaryArea', null);
|
||
};
|
||
/**
|
||
* Pins an item.
|
||
*
|
||
* @param {string} scope Item scope.
|
||
* @param {string} item Item identifier.
|
||
*
|
||
* @return {Object} Action object.
|
||
*/
|
||
|
||
const pinItem = (scope, item) => _ref3 => {
|
||
let {
|
||
registry
|
||
} = _ref3;
|
||
|
||
// 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 === null || pinnedItems === void 0 ? void 0 : 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) => _ref4 => {
|
||
let {
|
||
registry
|
||
} = _ref4;
|
||
|
||
// 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 (_ref5) {
|
||
let {
|
||
registry
|
||
} = _ref5;
|
||
external_wp_deprecated_default()(`wp.dispatch( 'core/interface' ).toggleFeature`, {
|
||
since: '6.0',
|
||
alternative: `wp.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 (_ref6) {
|
||
let {
|
||
registry
|
||
} = _ref6;
|
||
external_wp_deprecated_default()(`wp.dispatch( 'core/interface' ).setFeatureValue`, {
|
||
since: '6.0',
|
||
alternative: `wp.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 (_ref7) {
|
||
let {
|
||
registry
|
||
} = _ref7;
|
||
external_wp_deprecated_default()(`wp.dispatch( 'core/interface' ).setFeatureDefaults`, {
|
||
since: '6.0',
|
||
alternative: `wp.dispatch( 'core/preferences' ).setDefaults`
|
||
});
|
||
registry.dispatch(external_wp_preferences_namespaceObject.store).setDefaults(scope, defaults);
|
||
};
|
||
}
|
||
|
||
;// 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} The complementary area that is active in the given scope.
|
||
*/
|
||
|
||
const getActiveComplementaryArea = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
|
||
return select(external_wp_preferences_namespaceObject.store).get(scope, 'complementaryArea');
|
||
});
|
||
/**
|
||
* 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 === null || pinnedItems === void 0 ? void 0 : 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()(`wp.select( 'core/interface' ).isFeatureActive( scope, featureName )`, {
|
||
since: '6.0',
|
||
alternative: `!! wp.select( 'core/preferences' ).isFeatureActive( scope, featureName )`
|
||
});
|
||
return !!select(external_wp_preferences_namespaceObject.store).get(scope, featureName);
|
||
});
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/constants.js
|
||
/**
|
||
* The identifier for the data store.
|
||
*
|
||
* @type {string}
|
||
*/
|
||
const constants_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_store = (0,external_wp_data_namespaceObject.createReduxStore)(constants_STORE_NAME, {
|
||
reducer: () => {},
|
||
actions: store_actions_namespaceObject,
|
||
selectors: store_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_store);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/index.js
|
||
|
||
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-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: {
|
||
modifier: 'primary',
|
||
character: 'u'
|
||
},
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Underline the selected text.')
|
||
}];
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/shortcut.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
function KeyCombination(_ref) {
|
||
let {
|
||
keyCombination,
|
||
forceAriaLabel
|
||
} = _ref;
|
||
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;
|
||
return (0,external_wp_element_namespaceObject.createElement)("kbd", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key-combination",
|
||
"aria-label": forceAriaLabel || ariaLabel
|
||
}, (0,external_lodash_namespaceObject.castArray)(shortcut).map((character, index) => {
|
||
if (character === '+') {
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, {
|
||
key: index
|
||
}, character);
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)("kbd", {
|
||
key: index,
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key"
|
||
}, character);
|
||
}));
|
||
}
|
||
|
||
function Shortcut(_ref2) {
|
||
let {
|
||
description,
|
||
keyCombination,
|
||
aliases = [],
|
||
ariaLabel
|
||
} = _ref2;
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-description"
|
||
}, description), (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-term"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
|
||
keyCombination: keyCombination,
|
||
forceAriaLabel: ariaLabel
|
||
}), aliases.map((alias, index) => (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
|
||
keyCombination: alias,
|
||
forceAriaLabel: ariaLabel,
|
||
key: index
|
||
}))));
|
||
}
|
||
|
||
/* harmony default export */ var keyboard_shortcut_help_modal_shortcut = (Shortcut);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/dynamic-shortcut.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
function DynamicShortcut(_ref) {
|
||
let {
|
||
name
|
||
} = _ref;
|
||
const {
|
||
keyCombination,
|
||
description,
|
||
aliases
|
||
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
||
const {
|
||
getShortcutKeyCombination,
|
||
getShortcutDescription,
|
||
getShortcutAliases
|
||
} = select(external_wp_keyboardShortcuts_namespaceObject.store);
|
||
return {
|
||
keyCombination: getShortcutKeyCombination(name),
|
||
aliases: getShortcutAliases(name),
|
||
description: getShortcutDescription(name)
|
||
};
|
||
}, [name]);
|
||
|
||
if (!keyCombination) {
|
||
return null;
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
|
||
keyCombination: keyCombination,
|
||
description: description,
|
||
aliases: aliases
|
||
});
|
||
}
|
||
|
||
/* harmony default export */ var dynamic_shortcut = (DynamicShortcut);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/index.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
const ShortcutList = _ref => {
|
||
let {
|
||
shortcuts
|
||
} = _ref;
|
||
return (
|
||
/*
|
||
* Disable reason: The `list` ARIA role is redundant but
|
||
* Safari+VoiceOver won't announce the list otherwise.
|
||
*/
|
||
|
||
/* eslint-disable jsx-a11y/no-redundant-roles */
|
||
(0,external_wp_element_namespaceObject.createElement)("ul", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-list",
|
||
role: "list"
|
||
}, shortcuts.map((shortcut, index) => (0,external_wp_element_namespaceObject.createElement)("li", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut",
|
||
key: index
|
||
}, (0,external_lodash_namespaceObject.isString)(shortcut) ? (0,external_wp_element_namespaceObject.createElement)(dynamic_shortcut, {
|
||
name: shortcut
|
||
}) : (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, shortcut))))
|
||
/* eslint-enable jsx-a11y/no-redundant-roles */
|
||
|
||
);
|
||
};
|
||
|
||
const ShortcutSection = _ref2 => {
|
||
let {
|
||
title,
|
||
shortcuts,
|
||
className
|
||
} = _ref2;
|
||
return (0,external_wp_element_namespaceObject.createElement)("section", {
|
||
className: classnames_default()('customize-widgets-keyboard-shortcut-help-modal__section', className)
|
||
}, !!title && (0,external_wp_element_namespaceObject.createElement)("h2", {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__section-title"
|
||
}, title), (0,external_wp_element_namespaceObject.createElement)(ShortcutList, {
|
||
shortcuts: shortcuts
|
||
}));
|
||
};
|
||
|
||
const ShortcutCategorySection = _ref3 => {
|
||
let {
|
||
title,
|
||
categoryName,
|
||
additionalShortcuts = []
|
||
} = _ref3;
|
||
const categoryShortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
||
return select(external_wp_keyboardShortcuts_namespaceObject.store).getCategoryShortcuts(categoryName);
|
||
}, [categoryName]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
|
||
title: title,
|
||
shortcuts: categoryShortcuts.concat(additionalShortcuts)
|
||
});
|
||
};
|
||
|
||
function KeyboardShortcutHelpModal(_ref4) {
|
||
let {
|
||
isModalActive,
|
||
toggleModal
|
||
} = _ref4;
|
||
const {
|
||
registerShortcut
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
|
||
registerShortcut({
|
||
name: 'core/customize-widgets/keyboard-shortcuts',
|
||
category: 'main',
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Display these keyboard shortcuts.'),
|
||
keyCombination: {
|
||
modifier: 'access',
|
||
character: 'h'
|
||
}
|
||
});
|
||
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/keyboard-shortcuts', toggleModal);
|
||
|
||
if (!isModalActive) {
|
||
return null;
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Modal, {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal",
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts'),
|
||
closeLabel: (0,external_wp_i18n_namespaceObject.__)('Close'),
|
||
onRequestClose: toggleModal
|
||
}, (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
|
||
className: "customize-widgets-keyboard-shortcut-help-modal__main-shortcuts",
|
||
shortcuts: ['core/customize-widgets/keyboard-shortcuts']
|
||
}), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Global shortcuts'),
|
||
categoryName: "global"
|
||
}), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Selection shortcuts'),
|
||
categoryName: "selection"
|
||
}), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Block shortcuts'),
|
||
categoryName: "block",
|
||
additionalShortcuts: [{
|
||
keyCombination: {
|
||
character: '/'
|
||
},
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Change the block type after adding a new paragraph.'),
|
||
|
||
/* translators: The forward-slash character. e.g. '/'. */
|
||
ariaLabel: (0,external_wp_i18n_namespaceObject.__)('Forward-slash')
|
||
}]
|
||
}), (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Text formatting'),
|
||
shortcuts: textFormattingShortcuts
|
||
}));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-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/customize-widgets/keyboard-shortcuts', toggleKeyboardShortcutsModal);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(MoreMenuDropdown, {
|
||
as: external_wp_components_namespaceObject.ToolbarDropdownMenu
|
||
}, () => (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
||
label: (0,external_wp_i18n_namespaceObject._x)('View', 'noun')
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
|
||
scope: "core/customize-widgets",
|
||
name: "fixedToolbar",
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Top toolbar'),
|
||
info: (0,external_wp_i18n_namespaceObject.__)('Access all block and document tools in a single place'),
|
||
messageActivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar activated'),
|
||
messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar deactivated')
|
||
})), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Tools')
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
|
||
onClick: () => {
|
||
setIsKeyboardShortcutsModalVisible(true);
|
||
},
|
||
shortcut: external_wp_keycodes_namespaceObject.displayShortcut.access('h')
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts')), (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
|
||
scope: "core/customize-widgets",
|
||
name: "welcomeGuide",
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Welcome Guide')
|
||
}), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
|
||
role: "menuitem",
|
||
icon: library_external,
|
||
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/support/article/block-based-widgets-editor/'),
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Help'), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
|
||
as: "span"
|
||
},
|
||
/* translators: accessibility text */
|
||
(0,external_wp_i18n_namespaceObject.__)('(opens in a new tab)')))), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Preferences')
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
|
||
scope: "core/customize-widgets",
|
||
name: "keepCaretInsideBlock",
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block'),
|
||
info: (0,external_wp_i18n_namespaceObject.__)('Aids screen readers by stopping text caret from leaving blocks.'),
|
||
messageActivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block activated'),
|
||
messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block deactivated')
|
||
})))), (0,external_wp_element_namespaceObject.createElement)(KeyboardShortcutHelpModal, {
|
||
isModalActive: isKeyboardShortcutsModalActive,
|
||
toggleModal: toggleKeyboardShortcutsModal
|
||
}));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/header/index.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
function Header(_ref) {
|
||
let {
|
||
sidebar,
|
||
inserter,
|
||
isInserterOpened,
|
||
setIsInserterOpened,
|
||
isFixedToolbarActive
|
||
} = _ref;
|
||
const [[hasUndo, hasRedo], setUndoRedo] = (0,external_wp_element_namespaceObject.useState)([sidebar.hasUndo(), sidebar.hasRedo()]);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
return sidebar.subscribeHistory(() => {
|
||
setUndoRedo([sidebar.hasUndo(), sidebar.hasRedo()]);
|
||
});
|
||
}, [sidebar]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: classnames_default()('customize-widgets-header', {
|
||
'is-fixed-toolbar-active': isFixedToolbarActive
|
||
})
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.NavigableToolbar, {
|
||
className: "customize-widgets-header-toolbar",
|
||
"aria-label": (0,external_wp_i18n_namespaceObject.__)('Document tools')
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
|
||
icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_undo : library_redo
|
||
/* translators: button label text should, if possible, be under 16 characters. */
|
||
,
|
||
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: sidebar.undo,
|
||
className: "customize-widgets-editor-history-button undo-button"
|
||
}), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
|
||
icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_redo : library_undo
|
||
/* translators: button label text should, if possible, be under 16 characters. */
|
||
,
|
||
label: (0,external_wp_i18n_namespaceObject.__)('Redo'),
|
||
shortcut: external_wp_keycodes_namespaceObject.displayShortcut.primaryShift('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": !hasRedo,
|
||
onClick: sidebar.redo,
|
||
className: "customize-widgets-editor-history-button redo-button"
|
||
}), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
|
||
className: "customize-widgets-header-toolbar__inserter-toggle",
|
||
isPressed: isInserterOpened,
|
||
variant: "primary",
|
||
icon: library_plus,
|
||
label: (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button'),
|
||
onClick: () => {
|
||
setIsInserterOpened(isOpen => !isOpen);
|
||
}
|
||
}), (0,external_wp_element_namespaceObject.createElement)(MoreMenu, null))), (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)(components_inserter, {
|
||
setIsOpened: setIsInserterOpened
|
||
}), inserter.contentContainer[0]));
|
||
}
|
||
|
||
/* harmony default export */ var header = (Header);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/inserter/use-inserter.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
function useInserter(inserter) {
|
||
const isInserterOpened = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).isInserterOpened(), []);
|
||
const {
|
||
setIsInserterOpened
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(store);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
if (isInserterOpened) {
|
||
inserter.open();
|
||
} else {
|
||
inserter.close();
|
||
}
|
||
}, [inserter, isInserterOpened]);
|
||
return [isInserterOpened, (0,external_wp_element_namespaceObject.useCallback)(updater => {
|
||
let isOpen = updater;
|
||
|
||
if (typeof updater === 'function') {
|
||
isOpen = updater((0,external_wp_data_namespaceObject.select)(store).isInserterOpened());
|
||
}
|
||
|
||
setIsInserterOpened(isOpen);
|
||
}, [setIsInserterOpened])];
|
||
}
|
||
|
||
;// CONCATENATED MODULE: external ["wp","isShallowEqual"]
|
||
var external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
|
||
var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/utils.js
|
||
// @ts-check
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
|
||
/**
|
||
* Convert settingId to widgetId.
|
||
*
|
||
* @param {string} settingId The setting id.
|
||
* @return {string} The widget id.
|
||
*/
|
||
|
||
function settingIdToWidgetId(settingId) {
|
||
const matches = settingId.match(/^widget_(.+)(?:\[(\d+)\])$/);
|
||
|
||
if (matches) {
|
||
const idBase = matches[1];
|
||
const number = parseInt(matches[2], 10);
|
||
return `${idBase}-${number}`;
|
||
}
|
||
|
||
return settingId;
|
||
}
|
||
/**
|
||
* Transform a block to a customizable widget.
|
||
*
|
||
* @param {WPBlock} block The block to be transformed from.
|
||
* @param {Object} existingWidget The widget to be extended from.
|
||
* @return {Object} The transformed widget.
|
||
*/
|
||
|
||
function blockToWidget(block) {
|
||
let existingWidget = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
||
let widget;
|
||
const isValidLegacyWidgetBlock = block.name === 'core/legacy-widget' && (block.attributes.id || block.attributes.instance);
|
||
|
||
if (isValidLegacyWidgetBlock) {
|
||
if (block.attributes.id) {
|
||
// Widget that does not extend WP_Widget.
|
||
widget = {
|
||
id: block.attributes.id
|
||
};
|
||
} else {
|
||
const {
|
||
encoded,
|
||
hash,
|
||
raw,
|
||
...rest
|
||
} = block.attributes.instance; // Widget that extends WP_Widget.
|
||
|
||
widget = {
|
||
idBase: block.attributes.idBase,
|
||
instance: { ...(existingWidget === null || existingWidget === void 0 ? void 0 : existingWidget.instance),
|
||
// Required only for the customizer.
|
||
is_widget_customizer_js_value: true,
|
||
encoded_serialized_instance: encoded,
|
||
instance_hash_key: hash,
|
||
raw_instance: raw,
|
||
...rest
|
||
}
|
||
};
|
||
}
|
||
} else {
|
||
const instance = {
|
||
content: (0,external_wp_blocks_namespaceObject.serialize)(block)
|
||
};
|
||
widget = {
|
||
idBase: 'block',
|
||
widgetClass: 'WP_Widget_Block',
|
||
instance: {
|
||
raw_instance: instance
|
||
}
|
||
};
|
||
}
|
||
|
||
return { ...(0,external_lodash_namespaceObject.omit)(existingWidget, ['form', 'rendered']),
|
||
...widget
|
||
};
|
||
}
|
||
/**
|
||
* Transform a widget to a block.
|
||
*
|
||
* @param {Object} widget The widget to be transformed from.
|
||
* @param {string} widget.id The widget id.
|
||
* @param {string} widget.idBase The id base of the widget.
|
||
* @param {number} widget.number The number/index of the widget.
|
||
* @param {Object} widget.instance The instance of the widget.
|
||
* @return {WPBlock} The transformed block.
|
||
*/
|
||
|
||
function widgetToBlock(_ref) {
|
||
let {
|
||
id,
|
||
idBase,
|
||
number,
|
||
instance
|
||
} = _ref;
|
||
let block;
|
||
const {
|
||
encoded_serialized_instance: encoded,
|
||
instance_hash_key: hash,
|
||
raw_instance: raw,
|
||
...rest
|
||
} = instance;
|
||
|
||
if (idBase === 'block') {
|
||
const parsedBlocks = (0,external_wp_blocks_namespaceObject.parse)(raw.content);
|
||
block = parsedBlocks.length ? parsedBlocks[0] : (0,external_wp_blocks_namespaceObject.createBlock)('core/paragraph', {});
|
||
} else if (number) {
|
||
// Widget that extends WP_Widget.
|
||
block = (0,external_wp_blocks_namespaceObject.createBlock)('core/legacy-widget', {
|
||
idBase,
|
||
instance: {
|
||
encoded,
|
||
hash,
|
||
raw,
|
||
...rest
|
||
}
|
||
});
|
||
} else {
|
||
// Widget that does not extend WP_Widget.
|
||
block = (0,external_wp_blocks_namespaceObject.createBlock)('core/legacy-widget', {
|
||
id
|
||
});
|
||
}
|
||
|
||
return (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)(block, id);
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/use-sidebar-block-editor.js
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
function widgetsToBlocks(widgets) {
|
||
return widgets.map(widget => widgetToBlock(widget));
|
||
}
|
||
|
||
function useSidebarBlockEditor(sidebar) {
|
||
const [blocks, setBlocks] = (0,external_wp_element_namespaceObject.useState)(() => widgetsToBlocks(sidebar.getWidgets()));
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
return sidebar.subscribe((prevWidgets, nextWidgets) => {
|
||
setBlocks(prevBlocks => {
|
||
const prevWidgetsMap = new Map(prevWidgets.map(widget => [widget.id, widget]));
|
||
const prevBlocksMap = new Map(prevBlocks.map(block => [(0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block), block]));
|
||
const nextBlocks = nextWidgets.map(nextWidget => {
|
||
const prevWidget = prevWidgetsMap.get(nextWidget.id); // Bail out updates.
|
||
|
||
if (prevWidget && prevWidget === nextWidget) {
|
||
return prevBlocksMap.get(nextWidget.id);
|
||
}
|
||
|
||
return widgetToBlock(nextWidget);
|
||
}); // Bail out updates.
|
||
|
||
if (external_wp_isShallowEqual_default()(prevBlocks, nextBlocks)) {
|
||
return prevBlocks;
|
||
}
|
||
|
||
return nextBlocks;
|
||
});
|
||
});
|
||
}, [sidebar]);
|
||
const onChangeBlocks = (0,external_wp_element_namespaceObject.useCallback)(nextBlocks => {
|
||
setBlocks(prevBlocks => {
|
||
if (external_wp_isShallowEqual_default()(prevBlocks, nextBlocks)) {
|
||
return prevBlocks;
|
||
}
|
||
|
||
const prevBlocksMap = new Map(prevBlocks.map(block => [(0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block), block]));
|
||
const nextWidgets = nextBlocks.map(nextBlock => {
|
||
const widgetId = (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(nextBlock); // Update existing widgets.
|
||
|
||
if (widgetId && prevBlocksMap.has(widgetId)) {
|
||
const prevBlock = prevBlocksMap.get(widgetId);
|
||
const prevWidget = sidebar.getWidget(widgetId); // Bail out updates by returning the previous widgets.
|
||
// Deep equality is necessary until the block editor's internals changes.
|
||
|
||
if ((0,external_lodash_namespaceObject.isEqual)(nextBlock, prevBlock) && prevWidget) {
|
||
return prevWidget;
|
||
}
|
||
|
||
return blockToWidget(nextBlock, prevWidget);
|
||
} // Add a new widget.
|
||
|
||
|
||
return blockToWidget(nextBlock);
|
||
}); // Bail out updates if the updated widgets are the same.
|
||
|
||
if (external_wp_isShallowEqual_default()(sidebar.getWidgets(), nextWidgets)) {
|
||
return prevBlocks;
|
||
}
|
||
|
||
const addedWidgetIds = sidebar.setWidgets(nextWidgets);
|
||
return nextBlocks.reduce((updatedNextBlocks, nextBlock, index) => {
|
||
const addedWidgetId = addedWidgetIds[index];
|
||
|
||
if (addedWidgetId !== null) {
|
||
// Only create a new instance if necessary to prevent
|
||
// the whole editor from re-rendering on every edit.
|
||
if (updatedNextBlocks === nextBlocks) {
|
||
updatedNextBlocks = nextBlocks.slice();
|
||
}
|
||
|
||
updatedNextBlocks[index] = (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)(nextBlock, addedWidgetId);
|
||
}
|
||
|
||
return updatedNextBlocks;
|
||
}, nextBlocks);
|
||
});
|
||
}, [sidebar]);
|
||
return [blocks, onChangeBlocks, onChangeBlocks];
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/focus-control/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
const FocusControlContext = (0,external_wp_element_namespaceObject.createContext)();
|
||
function FocusControl(_ref) {
|
||
let {
|
||
api,
|
||
sidebarControls,
|
||
children
|
||
} = _ref;
|
||
const [focusedWidgetIdRef, setFocusedWidgetIdRef] = (0,external_wp_element_namespaceObject.useState)({
|
||
current: null
|
||
});
|
||
const focusWidget = (0,external_wp_element_namespaceObject.useCallback)(widgetId => {
|
||
for (const sidebarControl of sidebarControls) {
|
||
const widgets = sidebarControl.setting.get();
|
||
|
||
if (widgets.includes(widgetId)) {
|
||
sidebarControl.sectionInstance.expand({
|
||
// Schedule it after the complete callback so that
|
||
// it won't be overridden by the "Back" button focus.
|
||
completeCallback() {
|
||
// Create a "ref-like" object every time to ensure
|
||
// the same widget id can also triggers the focus control.
|
||
setFocusedWidgetIdRef({
|
||
current: widgetId
|
||
});
|
||
}
|
||
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}, [sidebarControls]);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
function handleFocus(settingId) {
|
||
const widgetId = settingIdToWidgetId(settingId);
|
||
focusWidget(widgetId);
|
||
}
|
||
|
||
function handleReady() {
|
||
api.previewer.preview.bind('focus-control-for-setting', handleFocus);
|
||
}
|
||
|
||
api.previewer.bind('ready', handleReady);
|
||
return () => {
|
||
api.previewer.unbind('ready', handleReady);
|
||
api.previewer.preview.unbind('focus-control-for-setting', handleFocus);
|
||
};
|
||
}, [api, focusWidget]);
|
||
const context = (0,external_wp_element_namespaceObject.useMemo)(() => [focusedWidgetIdRef, focusWidget], [focusedWidgetIdRef, focusWidget]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(FocusControlContext.Provider, {
|
||
value: context
|
||
}, children);
|
||
}
|
||
const useFocusControl = () => (0,external_wp_element_namespaceObject.useContext)(FocusControlContext);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/focus-control/use-blocks-focus-control.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
function useBlocksFocusControl(blocks) {
|
||
const {
|
||
selectBlock
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
|
||
const [focusedWidgetIdRef] = useFocusControl();
|
||
const blocksRef = (0,external_wp_element_namespaceObject.useRef)(blocks);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
blocksRef.current = blocks;
|
||
}, [blocks]);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
if (focusedWidgetIdRef.current) {
|
||
const focusedBlock = blocksRef.current.find(block => (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block) === focusedWidgetIdRef.current);
|
||
|
||
if (focusedBlock) {
|
||
selectBlock(focusedBlock.clientId); // If the block is already being selected, the DOM node won't
|
||
// get focused again automatically.
|
||
// We select the DOM and focus it manually here.
|
||
|
||
const blockNode = document.querySelector(`[data-block="${focusedBlock.clientId}"]`);
|
||
blockNode === null || blockNode === void 0 ? void 0 : blockNode.focus();
|
||
}
|
||
}
|
||
}, [focusedWidgetIdRef, selectBlock]);
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/sidebar-editor-provider.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
function SidebarEditorProvider(_ref) {
|
||
let {
|
||
sidebar,
|
||
settings,
|
||
children
|
||
} = _ref;
|
||
const [blocks, onInput, onChange] = useSidebarBlockEditor(sidebar);
|
||
useBlocksFocusControl(blocks);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockEditorProvider, {
|
||
value: blocks,
|
||
onInput: onInput,
|
||
onChange: onChange,
|
||
settings: settings,
|
||
useSubRegistry: false
|
||
}, children);
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/welcome-guide/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
function WelcomeGuide(_ref) {
|
||
let {
|
||
sidebar
|
||
} = _ref;
|
||
const {
|
||
toggle
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
|
||
const isEntirelyBlockWidgets = sidebar.getWidgets().every(widget => widget.id.startsWith('block-'));
|
||
return (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-welcome-guide"
|
||
}, (0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-welcome-guide__image__wrapper"
|
||
}, (0,external_wp_element_namespaceObject.createElement)("picture", null, (0,external_wp_element_namespaceObject.createElement)("source", {
|
||
srcSet: "https://s.w.org/images/block-editor/welcome-editor.svg",
|
||
media: "(prefers-reduced-motion: reduce)"
|
||
}), (0,external_wp_element_namespaceObject.createElement)("img", {
|
||
className: "customize-widgets-welcome-guide__image",
|
||
src: "https://s.w.org/images/block-editor/welcome-editor.gif",
|
||
width: "312",
|
||
height: "240",
|
||
alt: ""
|
||
}))), (0,external_wp_element_namespaceObject.createElement)("h1", {
|
||
className: "customize-widgets-welcome-guide__heading"
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets')), (0,external_wp_element_namespaceObject.createElement)("p", {
|
||
className: "customize-widgets-welcome-guide__text"
|
||
}, isEntirelyBlockWidgets ? (0,external_wp_i18n_namespaceObject.__)('Your theme provides 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.') : (0,external_wp_i18n_namespaceObject.__)('You can now add any block to your site’s widget areas. Don’t worry, all of your favorite widgets still work flawlessly.')), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
|
||
className: "customize-widgets-welcome-guide__button",
|
||
variant: "primary",
|
||
onClick: () => toggle('core/customize-widgets', 'welcomeGuide')
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Got it')), (0,external_wp_element_namespaceObject.createElement)("hr", {
|
||
className: "customize-widgets-welcome-guide__separator"
|
||
}), !isEntirelyBlockWidgets && (0,external_wp_element_namespaceObject.createElement)("p", {
|
||
className: "customize-widgets-welcome-guide__more-info"
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Want to stick with the old widgets?'), (0,external_wp_element_namespaceObject.createElement)("br", null), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
|
||
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/plugins/classic-widgets/')
|
||
}, (0,external_wp_i18n_namespaceObject.__)('Get the Classic Widgets plugin.'))), (0,external_wp_element_namespaceObject.createElement)("p", {
|
||
className: "customize-widgets-welcome-guide__more-info"
|
||
}, (0,external_wp_i18n_namespaceObject.__)('New to the block editor?'), (0,external_wp_element_namespaceObject.createElement)("br", null), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
|
||
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/support/article/wordpress-editor/')
|
||
}, (0,external_wp_i18n_namespaceObject.__)("Here's a detailed guide."))));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcuts/index.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
function KeyboardShortcuts(_ref) {
|
||
let {
|
||
undo,
|
||
redo,
|
||
save
|
||
} = _ref;
|
||
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/undo', event => {
|
||
undo();
|
||
event.preventDefault();
|
||
});
|
||
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/redo', event => {
|
||
redo();
|
||
event.preventDefault();
|
||
});
|
||
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/save', event => {
|
||
event.preventDefault();
|
||
save();
|
||
});
|
||
return null;
|
||
}
|
||
|
||
function KeyboardShortcutsRegister() {
|
||
const {
|
||
registerShortcut,
|
||
unregisterShortcut
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
registerShortcut({
|
||
name: 'core/customize-widgets/undo',
|
||
category: 'global',
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Undo your last changes.'),
|
||
keyCombination: {
|
||
modifier: 'primary',
|
||
character: 'z'
|
||
}
|
||
});
|
||
registerShortcut({
|
||
name: 'core/customize-widgets/redo',
|
||
category: 'global',
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Redo your last undo.'),
|
||
keyCombination: {
|
||
modifier: 'primaryShift',
|
||
character: 'z'
|
||
}
|
||
});
|
||
registerShortcut({
|
||
name: 'core/customize-widgets/save',
|
||
category: 'global',
|
||
description: (0,external_wp_i18n_namespaceObject.__)('Save your changes.'),
|
||
keyCombination: {
|
||
modifier: 'primary',
|
||
character: 's'
|
||
}
|
||
});
|
||
return () => {
|
||
unregisterShortcut('core/customize-widgets/undo');
|
||
unregisterShortcut('core/customize-widgets/redo');
|
||
unregisterShortcut('core/customize-widgets/save');
|
||
};
|
||
}, [registerShortcut]);
|
||
return null;
|
||
}
|
||
|
||
KeyboardShortcuts.Register = KeyboardShortcutsRegister;
|
||
/* harmony default export */ var keyboard_shortcuts = (KeyboardShortcuts);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/block-appender/index.js
|
||
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
function BlockAppender(props) {
|
||
const ref = (0,external_wp_element_namespaceObject.useRef)();
|
||
const isBlocksListEmpty = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getBlockCount() === 0); // Move the focus to the block appender to prevent focus from
|
||
// being lost when emptying the widget area.
|
||
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
if (isBlocksListEmpty && ref.current) {
|
||
const {
|
||
ownerDocument
|
||
} = ref.current;
|
||
|
||
if (!ownerDocument.activeElement || ownerDocument.activeElement === ownerDocument.body) {
|
||
ref.current.focus();
|
||
}
|
||
}
|
||
}, [isBlocksListEmpty]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.ButtonBlockAppender, _extends({}, props, {
|
||
ref: ref
|
||
}));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/index.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
function SidebarBlockEditor(_ref) {
|
||
let {
|
||
blockEditorSettings,
|
||
sidebar,
|
||
inserter,
|
||
inspector
|
||
} = _ref;
|
||
const [isInserterOpened, setIsInserterOpened] = useInserter(inserter);
|
||
const {
|
||
hasUploadPermissions,
|
||
isFixedToolbarActive,
|
||
keepCaretInsideBlock,
|
||
isWelcomeGuideActive
|
||
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
||
const {
|
||
get
|
||
} = select(external_wp_preferences_namespaceObject.store);
|
||
return {
|
||
hasUploadPermissions: (0,external_lodash_namespaceObject.defaultTo)(select(external_wp_coreData_namespaceObject.store).canUser('create', 'media'), true),
|
||
isFixedToolbarActive: !!get('core/customize-widgets', 'fixedToolbar'),
|
||
keepCaretInsideBlock: !!get('core/customize-widgets', 'keepCaretInsideBlock'),
|
||
isWelcomeGuideActive: !!get('core/customize-widgets', 'welcomeGuide')
|
||
};
|
||
}, []);
|
||
const settings = (0,external_wp_element_namespaceObject.useMemo)(() => {
|
||
let mediaUploadBlockEditor;
|
||
|
||
if (hasUploadPermissions) {
|
||
mediaUploadBlockEditor = _ref2 => {
|
||
let {
|
||
onError,
|
||
...argumentsObject
|
||
} = _ref2;
|
||
(0,external_wp_mediaUtils_namespaceObject.uploadMedia)({
|
||
wpAllowedMimeTypes: blockEditorSettings.allowedMimeTypes,
|
||
onError: _ref3 => {
|
||
let {
|
||
message
|
||
} = _ref3;
|
||
return onError(message);
|
||
},
|
||
...argumentsObject
|
||
});
|
||
};
|
||
}
|
||
|
||
return { ...blockEditorSettings,
|
||
__experimentalSetIsInserterOpened: setIsInserterOpened,
|
||
mediaUpload: mediaUploadBlockEditor,
|
||
hasFixedToolbar: isFixedToolbarActive,
|
||
keepCaretInsideBlock,
|
||
__unstableHasCustomAppender: true
|
||
};
|
||
}, [hasUploadPermissions, blockEditorSettings, isFixedToolbarActive, keepCaretInsideBlock, setIsInserterOpened]);
|
||
|
||
if (isWelcomeGuideActive) {
|
||
return (0,external_wp_element_namespaceObject.createElement)(WelcomeGuide, {
|
||
sidebar: sidebar
|
||
});
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockEditorKeyboardShortcuts.Register, null), (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts.Register, null), (0,external_wp_element_namespaceObject.createElement)(SidebarEditorProvider, {
|
||
sidebar: sidebar,
|
||
settings: settings
|
||
}, (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts, {
|
||
undo: sidebar.undo,
|
||
redo: sidebar.redo,
|
||
save: sidebar.save
|
||
}), (0,external_wp_element_namespaceObject.createElement)(header, {
|
||
sidebar: sidebar,
|
||
inserter: inserter,
|
||
isInserterOpened: isInserterOpened,
|
||
setIsInserterOpened: setIsInserterOpened,
|
||
isFixedToolbarActive: isFixedToolbarActive
|
||
}), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.CopyHandler, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockTools, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableEditorStyles, {
|
||
styles: settings.defaultEditorStyles
|
||
}), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockSelectionClearer, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.WritingFlow, {
|
||
className: "editor-styles-wrapper"
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.ObserveTyping, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockList, {
|
||
renderAppender: BlockAppender
|
||
})))))), (0,external_wp_element_namespaceObject.createPortal)( // This is a temporary hack to prevent button component inside <BlockInspector>
|
||
// from submitting form when type="button" is not specified.
|
||
(0,external_wp_element_namespaceObject.createElement)("form", {
|
||
onSubmit: event => event.preventDefault()
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockInspector, null)), inspector.contentContainer[0])), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableBlockSettingsMenuFirstItem, null, _ref4 => {
|
||
let {
|
||
onClose
|
||
} = _ref4;
|
||
return (0,external_wp_element_namespaceObject.createElement)(block_inspector_button, {
|
||
inspector: inspector,
|
||
closeMenu: onClose
|
||
});
|
||
}));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-controls/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
const SidebarControlsContext = (0,external_wp_element_namespaceObject.createContext)();
|
||
function SidebarControls(_ref) {
|
||
let {
|
||
sidebarControls,
|
||
activeSidebarControl,
|
||
children
|
||
} = _ref;
|
||
const context = (0,external_wp_element_namespaceObject.useMemo)(() => ({
|
||
sidebarControls,
|
||
activeSidebarControl
|
||
}), [sidebarControls, activeSidebarControl]);
|
||
return (0,external_wp_element_namespaceObject.createElement)(SidebarControlsContext.Provider, {
|
||
value: context
|
||
}, children);
|
||
}
|
||
function useSidebarControls() {
|
||
const {
|
||
sidebarControls
|
||
} = (0,external_wp_element_namespaceObject.useContext)(SidebarControlsContext);
|
||
return sidebarControls;
|
||
}
|
||
function useActiveSidebarControl() {
|
||
const {
|
||
activeSidebarControl
|
||
} = (0,external_wp_element_namespaceObject.useContext)(SidebarControlsContext);
|
||
return activeSidebarControl;
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/customize-widgets/use-clear-selected-block.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* We can't just use <BlockSelectionClearer> because the customizer has
|
||
* many root nodes rather than just one in the post editor.
|
||
* We need to listen to the focus events in all those roots, and also in
|
||
* the preview iframe.
|
||
* This hook will clear the selected block when focusing outside the editor,
|
||
* with a few exceptions:
|
||
* 1. Focusing on popovers.
|
||
* 2. Focusing on the inspector.
|
||
* 3. Focusing on any modals/dialogs.
|
||
* These cases are normally triggered by user interactions from the editor,
|
||
* not by explicitly focusing outside the editor, hence no need for clearing.
|
||
*
|
||
* @param {Object} sidebarControl The sidebar control instance.
|
||
* @param {Object} popoverRef The ref object of the popover node container.
|
||
*/
|
||
|
||
function useClearSelectedBlock(sidebarControl, popoverRef) {
|
||
const {
|
||
hasSelectedBlock,
|
||
hasMultiSelection
|
||
} = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blockEditor_namespaceObject.store);
|
||
const {
|
||
clearSelectedBlock
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
if (popoverRef.current && sidebarControl) {
|
||
const inspector = sidebarControl.inspector;
|
||
const container = sidebarControl.container[0];
|
||
const ownerDocument = container.ownerDocument;
|
||
const ownerWindow = ownerDocument.defaultView;
|
||
|
||
function handleClearSelectedBlock(element) {
|
||
if ( // 1. Make sure there are blocks being selected.
|
||
(hasSelectedBlock() || hasMultiSelection()) && // 2. The element should exist in the DOM (not deleted).
|
||
element && ownerDocument.contains(element) && // 3. It should also not exist in the container, the popover, nor the dialog.
|
||
!container.contains(element) && !popoverRef.current.contains(element) && !element.closest('[role="dialog"]') && // 4. The inspector should not be opened.
|
||
!inspector.expanded()) {
|
||
clearSelectedBlock();
|
||
}
|
||
} // Handle mouse down in the same document.
|
||
|
||
|
||
function handleMouseDown(event) {
|
||
handleClearSelectedBlock(event.target);
|
||
} // Handle focusing outside the current document, like to iframes.
|
||
|
||
|
||
function handleBlur() {
|
||
handleClearSelectedBlock(ownerDocument.activeElement);
|
||
}
|
||
|
||
ownerDocument.addEventListener('mousedown', handleMouseDown);
|
||
ownerWindow.addEventListener('blur', handleBlur);
|
||
return () => {
|
||
ownerDocument.removeEventListener('mousedown', handleMouseDown);
|
||
ownerWindow.removeEventListener('blur', handleBlur);
|
||
};
|
||
}
|
||
}, [popoverRef, sidebarControl, hasSelectedBlock, hasMultiSelection, clearSelectedBlock]);
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/customize-widgets/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
function CustomizeWidgets(_ref) {
|
||
let {
|
||
api,
|
||
sidebarControls,
|
||
blockEditorSettings
|
||
} = _ref;
|
||
const [activeSidebarControl, setActiveSidebarControl] = (0,external_wp_element_namespaceObject.useState)(null);
|
||
const parentContainer = document.getElementById('customize-theme-controls');
|
||
const popoverRef = (0,external_wp_element_namespaceObject.useRef)();
|
||
useClearSelectedBlock(activeSidebarControl, popoverRef);
|
||
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
||
const unsubscribers = sidebarControls.map(sidebarControl => sidebarControl.subscribe(expanded => {
|
||
if (expanded) {
|
||
setActiveSidebarControl(sidebarControl);
|
||
}
|
||
}));
|
||
return () => {
|
||
unsubscribers.forEach(unsubscriber => unsubscriber());
|
||
};
|
||
}, [sidebarControls]);
|
||
const activeSidebar = activeSidebarControl && (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)(ErrorBoundary, null, (0,external_wp_element_namespaceObject.createElement)(SidebarBlockEditor, {
|
||
key: activeSidebarControl.id,
|
||
blockEditorSettings: blockEditorSettings,
|
||
sidebar: activeSidebarControl.sidebarAdapter,
|
||
inserter: activeSidebarControl.inserter,
|
||
inspector: activeSidebarControl.inspector
|
||
})), activeSidebarControl.container[0]); // We have to portal this to the parent of both the editor and the inspector,
|
||
// so that the popovers will appear above both of them.
|
||
|
||
const popover = parentContainer && (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)("div", {
|
||
className: "customize-widgets-popover",
|
||
ref: popoverRef
|
||
}, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Popover.Slot, null)), parentContainer);
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_keyboardShortcuts_namespaceObject.ShortcutProvider, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.SlotFillProvider, null, (0,external_wp_element_namespaceObject.createElement)(SidebarControls, {
|
||
sidebarControls: sidebarControls,
|
||
activeSidebarControl: activeSidebarControl
|
||
}, (0,external_wp_element_namespaceObject.createElement)(FocusControl, {
|
||
api: api,
|
||
sidebarControls: sidebarControls
|
||
}, activeSidebar, popover))));
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/inspector-section.js
|
||
function getInspectorSection() {
|
||
const {
|
||
wp: {
|
||
customize
|
||
}
|
||
} = window;
|
||
return class InspectorSection extends customize.Section {
|
||
constructor(id, options) {
|
||
super(id, options);
|
||
this.parentSection = options.parentSection;
|
||
this.returnFocusWhenClose = null;
|
||
this._isOpen = false;
|
||
}
|
||
|
||
get isOpen() {
|
||
return this._isOpen;
|
||
}
|
||
|
||
set isOpen(value) {
|
||
this._isOpen = value;
|
||
this.triggerActiveCallbacks();
|
||
}
|
||
|
||
ready() {
|
||
this.contentContainer[0].classList.add('customize-widgets-layout__inspector');
|
||
}
|
||
|
||
isContextuallyActive() {
|
||
return this.isOpen;
|
||
}
|
||
|
||
onChangeExpanded(expanded, args) {
|
||
super.onChangeExpanded(expanded, args);
|
||
|
||
if (this.parentSection && !args.unchanged) {
|
||
if (expanded) {
|
||
this.parentSection.collapse({
|
||
manualTransition: true
|
||
});
|
||
} else {
|
||
this.parentSection.expand({
|
||
manualTransition: true,
|
||
completeCallback: () => {
|
||
// Return focus after finishing the transition.
|
||
if (this.returnFocusWhenClose && !this.contentContainer[0].contains(this.returnFocusWhenClose)) {
|
||
this.returnFocusWhenClose.focus();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
open() {
|
||
let {
|
||
returnFocusWhenClose
|
||
} = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
||
this.isOpen = true;
|
||
this.returnFocusWhenClose = returnFocusWhenClose;
|
||
this.expand({
|
||
allowMultiple: true
|
||
});
|
||
}
|
||
|
||
close() {
|
||
this.collapse({
|
||
allowMultiple: true
|
||
});
|
||
}
|
||
|
||
collapse(options) {
|
||
// Overridden collapse() function. Mostly call the parent collapse(), but also
|
||
// move our .isOpen to false.
|
||
// Initially, I tried tracking this with onChangeExpanded(), but it doesn't work
|
||
// because the block settings sidebar is a layer "on top of" the G editor sidebar.
|
||
//
|
||
// For example, when closing the block settings sidebar, the G
|
||
// editor sidebar would display, and onChangeExpanded in
|
||
// inspector-section would run with expanded=true, but I want
|
||
// isOpen to be false when the block settings is closed.
|
||
this.isOpen = false;
|
||
super.collapse(options);
|
||
}
|
||
|
||
triggerActiveCallbacks() {
|
||
// Manually fire the callbacks associated with moving this.active
|
||
// from false to true. "active" is always true for this section,
|
||
// and "isContextuallyActive" reflects if the block settings
|
||
// sidebar is currently visible, that is, it has replaced the main
|
||
// Gutenberg view.
|
||
// The WP customizer only checks ".isContextuallyActive()" when
|
||
// ".active" changes values. But our ".active" never changes value.
|
||
// The WP customizer never foresaw a section being used a way we
|
||
// fit the block settings sidebar into a section. By manually
|
||
// triggering the "this.active" callbacks, we force the WP
|
||
// customizer to query our .isContextuallyActive() function and
|
||
// update its view of our status.
|
||
this.active.callbacks.fireWith(this.active, [false, true]);
|
||
}
|
||
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/sidebar-section.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
const getInspectorSectionId = sidebarId => `widgets-inspector-${sidebarId}`;
|
||
|
||
function getSidebarSection() {
|
||
const {
|
||
wp: {
|
||
customize
|
||
}
|
||
} = window;
|
||
const reduceMotionMediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
|
||
let isReducedMotion = reduceMotionMediaQuery.matches;
|
||
reduceMotionMediaQuery.addEventListener('change', event => {
|
||
isReducedMotion = event.matches;
|
||
});
|
||
return class SidebarSection extends customize.Section {
|
||
ready() {
|
||
const InspectorSection = getInspectorSection();
|
||
this.inspector = new InspectorSection(getInspectorSectionId(this.id), {
|
||
title: (0,external_wp_i18n_namespaceObject.__)('Block Settings'),
|
||
parentSection: this,
|
||
customizeAction: [(0,external_wp_i18n_namespaceObject.__)('Customizing'), (0,external_wp_i18n_namespaceObject.__)('Widgets'), this.params.title].join(' ▸ ')
|
||
});
|
||
customize.section.add(this.inspector);
|
||
this.contentContainer[0].classList.add('customize-widgets__sidebar-section');
|
||
}
|
||
|
||
hasSubSectionOpened() {
|
||
return this.inspector.expanded();
|
||
}
|
||
|
||
onChangeExpanded(expanded, _args) {
|
||
const controls = this.controls();
|
||
const args = { ..._args,
|
||
|
||
completeCallback() {
|
||
var _args$completeCallbac;
|
||
|
||
controls.forEach(control => {
|
||
var _control$onChangeSect;
|
||
|
||
(_control$onChangeSect = control.onChangeSectionExpanded) === null || _control$onChangeSect === void 0 ? void 0 : _control$onChangeSect.call(control, expanded, args);
|
||
});
|
||
(_args$completeCallbac = _args.completeCallback) === null || _args$completeCallbac === void 0 ? void 0 : _args$completeCallbac.call(_args);
|
||
}
|
||
|
||
};
|
||
|
||
if (args.manualTransition) {
|
||
if (expanded) {
|
||
this.contentContainer.addClass(['busy', 'open']);
|
||
this.contentContainer.removeClass('is-sub-section-open');
|
||
this.contentContainer.closest('.wp-full-overlay').addClass('section-open');
|
||
} else {
|
||
this.contentContainer.addClass(['busy', 'is-sub-section-open']);
|
||
this.contentContainer.closest('.wp-full-overlay').addClass('section-open');
|
||
this.contentContainer.removeClass('open');
|
||
}
|
||
|
||
const handleTransitionEnd = () => {
|
||
this.contentContainer.removeClass('busy');
|
||
args.completeCallback();
|
||
};
|
||
|
||
if (isReducedMotion) {
|
||
handleTransitionEnd();
|
||
} else {
|
||
this.contentContainer.one('transitionend', handleTransitionEnd);
|
||
}
|
||
} else {
|
||
super.onChangeExpanded(expanded, args);
|
||
}
|
||
}
|
||
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/sidebar-adapter.js
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
const {
|
||
wp
|
||
} = window;
|
||
|
||
function parseWidgetId(widgetId) {
|
||
const matches = widgetId.match(/^(.+)-(\d+)$/);
|
||
|
||
if (matches) {
|
||
return {
|
||
idBase: matches[1],
|
||
number: parseInt(matches[2], 10)
|
||
};
|
||
} // Likely an old single widget.
|
||
|
||
|
||
return {
|
||
idBase: widgetId
|
||
};
|
||
}
|
||
|
||
function widgetIdToSettingId(widgetId) {
|
||
const {
|
||
idBase,
|
||
number
|
||
} = parseWidgetId(widgetId);
|
||
|
||
if (number) {
|
||
return `widget_${idBase}[${number}]`;
|
||
}
|
||
|
||
return `widget_${idBase}`;
|
||
}
|
||
/**
|
||
* This is a custom debounce function to call different callbacks depending on
|
||
* whether it's the _leading_ call or not.
|
||
*
|
||
* @param {Function} leading The callback that gets called first.
|
||
* @param {Function} callback The callback that gets called after the first time.
|
||
* @param {number} timeout The debounced time in milliseconds.
|
||
* @return {Function} The debounced function.
|
||
*/
|
||
|
||
|
||
function debounce(leading, callback, timeout) {
|
||
let isLeading = false;
|
||
let timerID;
|
||
|
||
function debounced() {
|
||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
|
||
const result = (isLeading ? callback : leading).apply(this, args);
|
||
isLeading = true;
|
||
clearTimeout(timerID);
|
||
timerID = setTimeout(() => {
|
||
isLeading = false;
|
||
}, timeout);
|
||
return result;
|
||
}
|
||
|
||
debounced.cancel = () => {
|
||
isLeading = false;
|
||
clearTimeout(timerID);
|
||
};
|
||
|
||
return debounced;
|
||
}
|
||
|
||
class SidebarAdapter {
|
||
constructor(setting, api) {
|
||
this.setting = setting;
|
||
this.api = api;
|
||
this.locked = false;
|
||
this.widgetsCache = new WeakMap();
|
||
this.subscribers = new Set();
|
||
this.history = [this._getWidgetIds().map(widgetId => this.getWidget(widgetId))];
|
||
this.historyIndex = 0;
|
||
this.historySubscribers = new Set(); // Debounce the input for 1 second.
|
||
|
||
this._debounceSetHistory = debounce(this._pushHistory, this._replaceHistory, 1000);
|
||
this.setting.bind(this._handleSettingChange.bind(this));
|
||
this.api.bind('change', this._handleAllSettingsChange.bind(this));
|
||
this.undo = this.undo.bind(this);
|
||
this.redo = this.redo.bind(this);
|
||
this.save = this.save.bind(this);
|
||
}
|
||
|
||
subscribe(callback) {
|
||
this.subscribers.add(callback);
|
||
return () => {
|
||
this.subscribers.delete(callback);
|
||
};
|
||
}
|
||
|
||
getWidgets() {
|
||
return this.history[this.historyIndex];
|
||
}
|
||
|
||
_emit() {
|
||
for (const callback of this.subscribers) {
|
||
callback(...arguments);
|
||
}
|
||
}
|
||
|
||
_getWidgetIds() {
|
||
return this.setting.get();
|
||
}
|
||
|
||
_pushHistory() {
|
||
this.history = [...this.history.slice(0, this.historyIndex + 1), this._getWidgetIds().map(widgetId => this.getWidget(widgetId))];
|
||
this.historyIndex += 1;
|
||
this.historySubscribers.forEach(listener => listener());
|
||
}
|
||
|
||
_replaceHistory() {
|
||
this.history[this.historyIndex] = this._getWidgetIds().map(widgetId => this.getWidget(widgetId));
|
||
}
|
||
|
||
_handleSettingChange() {
|
||
if (this.locked) {
|
||
return;
|
||
}
|
||
|
||
const prevWidgets = this.getWidgets();
|
||
|
||
this._pushHistory();
|
||
|
||
this._emit(prevWidgets, this.getWidgets());
|
||
}
|
||
|
||
_handleAllSettingsChange(setting) {
|
||
if (this.locked) {
|
||
return;
|
||
}
|
||
|
||
if (!setting.id.startsWith('widget_')) {
|
||
return;
|
||
}
|
||
|
||
const widgetId = settingIdToWidgetId(setting.id);
|
||
|
||
if (!this.setting.get().includes(widgetId)) {
|
||
return;
|
||
}
|
||
|
||
const prevWidgets = this.getWidgets();
|
||
|
||
this._pushHistory();
|
||
|
||
this._emit(prevWidgets, this.getWidgets());
|
||
}
|
||
|
||
_createWidget(widget) {
|
||
const widgetModel = wp.customize.Widgets.availableWidgets.findWhere({
|
||
id_base: widget.idBase
|
||
});
|
||
let number = widget.number;
|
||
|
||
if (widgetModel.get('is_multi') && !number) {
|
||
widgetModel.set('multi_number', widgetModel.get('multi_number') + 1);
|
||
number = widgetModel.get('multi_number');
|
||
}
|
||
|
||
const settingId = number ? `widget_${widget.idBase}[${number}]` : `widget_${widget.idBase}`;
|
||
const settingArgs = {
|
||
transport: wp.customize.Widgets.data.selectiveRefreshableWidgets[widgetModel.get('id_base')] ? 'postMessage' : 'refresh',
|
||
previewer: this.setting.previewer
|
||
};
|
||
const setting = this.api.create(settingId, settingId, '', settingArgs);
|
||
setting.set(widget.instance);
|
||
const widgetId = settingIdToWidgetId(settingId);
|
||
return widgetId;
|
||
}
|
||
|
||
_removeWidget(widget) {
|
||
const settingId = widgetIdToSettingId(widget.id);
|
||
const setting = this.api(settingId);
|
||
|
||
if (setting) {
|
||
const instance = setting.get();
|
||
this.widgetsCache.delete(instance);
|
||
}
|
||
|
||
this.api.remove(settingId);
|
||
}
|
||
|
||
_updateWidget(widget) {
|
||
const prevWidget = this.getWidget(widget.id); // Bail out update if nothing changed.
|
||
|
||
if (prevWidget === widget) {
|
||
return widget.id;
|
||
} // Update existing setting if only the widget's instance changed.
|
||
|
||
|
||
if (prevWidget.idBase && widget.idBase && prevWidget.idBase === widget.idBase) {
|
||
const settingId = widgetIdToSettingId(widget.id);
|
||
this.api(settingId).set(widget.instance);
|
||
return widget.id;
|
||
} // Otherwise delete and re-create.
|
||
|
||
|
||
this._removeWidget(widget);
|
||
|
||
return this._createWidget(widget);
|
||
}
|
||
|
||
getWidget(widgetId) {
|
||
if (!widgetId) {
|
||
return null;
|
||
}
|
||
|
||
const {
|
||
idBase,
|
||
number
|
||
} = parseWidgetId(widgetId);
|
||
const settingId = widgetIdToSettingId(widgetId);
|
||
const setting = this.api(settingId);
|
||
|
||
if (!setting) {
|
||
return null;
|
||
}
|
||
|
||
const instance = setting.get();
|
||
|
||
if (this.widgetsCache.has(instance)) {
|
||
return this.widgetsCache.get(instance);
|
||
}
|
||
|
||
const widget = {
|
||
id: widgetId,
|
||
idBase,
|
||
number,
|
||
instance
|
||
};
|
||
this.widgetsCache.set(instance, widget);
|
||
return widget;
|
||
}
|
||
|
||
_updateWidgets(nextWidgets) {
|
||
this.locked = true;
|
||
const addedWidgetIds = [];
|
||
const nextWidgetIds = nextWidgets.map(nextWidget => {
|
||
if (nextWidget.id && this.getWidget(nextWidget.id)) {
|
||
addedWidgetIds.push(null);
|
||
return this._updateWidget(nextWidget);
|
||
}
|
||
|
||
const widgetId = this._createWidget(nextWidget);
|
||
|
||
addedWidgetIds.push(widgetId);
|
||
return widgetId;
|
||
});
|
||
const deletedWidgets = this.getWidgets().filter(widget => !nextWidgetIds.includes(widget.id));
|
||
deletedWidgets.forEach(widget => this._removeWidget(widget));
|
||
this.setting.set(nextWidgetIds);
|
||
this.locked = false;
|
||
return addedWidgetIds;
|
||
}
|
||
|
||
setWidgets(nextWidgets) {
|
||
const addedWidgetIds = this._updateWidgets(nextWidgets);
|
||
|
||
this._debounceSetHistory();
|
||
|
||
return addedWidgetIds;
|
||
}
|
||
/**
|
||
* Undo/Redo related features
|
||
*/
|
||
|
||
|
||
hasUndo() {
|
||
return this.historyIndex > 0;
|
||
}
|
||
|
||
hasRedo() {
|
||
return this.historyIndex < this.history.length - 1;
|
||
}
|
||
|
||
_seek(historyIndex) {
|
||
const currentWidgets = this.getWidgets();
|
||
this.historyIndex = historyIndex;
|
||
const widgets = this.history[this.historyIndex];
|
||
|
||
this._updateWidgets(widgets);
|
||
|
||
this._emit(currentWidgets, this.getWidgets());
|
||
|
||
this.historySubscribers.forEach(listener => listener());
|
||
|
||
this._debounceSetHistory.cancel();
|
||
}
|
||
|
||
undo() {
|
||
if (!this.hasUndo()) {
|
||
return;
|
||
}
|
||
|
||
this._seek(this.historyIndex - 1);
|
||
}
|
||
|
||
redo() {
|
||
if (!this.hasRedo()) {
|
||
return;
|
||
}
|
||
|
||
this._seek(this.historyIndex + 1);
|
||
}
|
||
|
||
subscribeHistory(listener) {
|
||
this.historySubscribers.add(listener);
|
||
return () => {
|
||
this.historySubscribers.delete(listener);
|
||
};
|
||
}
|
||
|
||
save() {
|
||
this.api.previewer.save();
|
||
}
|
||
|
||
}
|
||
|
||
;// CONCATENATED MODULE: external ["wp","dom"]
|
||
var external_wp_dom_namespaceObject = window["wp"]["dom"];
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/inserter-outer-section.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
function getInserterOuterSection() {
|
||
const {
|
||
wp: {
|
||
customize
|
||
}
|
||
} = window;
|
||
const OuterSection = customize.OuterSection; // Override the OuterSection class to handle multiple outer sections.
|
||
// It closes all the other outer sections whenever one is opened.
|
||
// The result is that at most one outer section can be opened at the same time.
|
||
|
||
customize.OuterSection = class extends OuterSection {
|
||
onChangeExpanded(expanded, args) {
|
||
if (expanded) {
|
||
customize.section.each(section => {
|
||
if (section.params.type === 'outer' && section.id !== this.id) {
|
||
if (section.expanded()) {
|
||
section.collapse();
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
return super.onChangeExpanded(expanded, args);
|
||
}
|
||
|
||
}; // Handle constructor so that "params.type" can be correctly pointed to "outer".
|
||
|
||
customize.sectionConstructor.outer = customize.OuterSection;
|
||
return class InserterOuterSection extends customize.OuterSection {
|
||
constructor() {
|
||
super(...arguments); // This is necessary since we're creating a new class which is not identical to the original OuterSection.
|
||
// @See https://github.com/WordPress/wordpress-develop/blob/42b05c397c50d9dc244083eff52991413909d4bd/src/js/_enqueues/wp/customize/controls.js#L1427-L1436
|
||
|
||
this.params.type = 'outer';
|
||
this.activeElementBeforeExpanded = null;
|
||
const ownerWindow = this.contentContainer[0].ownerDocument.defaultView; // Handle closing the inserter when pressing the Escape key.
|
||
|
||
ownerWindow.addEventListener('keydown', event => {
|
||
if (this.expanded() && (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE || event.code === 'Escape') && !event.defaultPrevented) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
(0,external_wp_data_namespaceObject.dispatch)(store).setIsInserterOpened(false);
|
||
}
|
||
}, // Use capture mode to make this run before other event listeners.
|
||
true);
|
||
this.contentContainer.addClass('widgets-inserter'); // Set a flag if the state is being changed from open() or close().
|
||
// Don't propagate the event if it's an internal action to prevent infinite loop.
|
||
|
||
this.isFromInternalAction = false;
|
||
this.expanded.bind(() => {
|
||
if (!this.isFromInternalAction) {
|
||
// Propagate the event to React to sync the state.
|
||
(0,external_wp_data_namespaceObject.dispatch)(store).setIsInserterOpened(this.expanded());
|
||
}
|
||
|
||
this.isFromInternalAction = false;
|
||
});
|
||
}
|
||
|
||
open() {
|
||
if (!this.expanded()) {
|
||
const contentContainer = this.contentContainer[0];
|
||
this.activeElementBeforeExpanded = contentContainer.ownerDocument.activeElement;
|
||
this.isFromInternalAction = true;
|
||
this.expand({
|
||
completeCallback() {
|
||
// We have to do this in a "completeCallback" or else the elements will not yet be visible/tabbable.
|
||
// The first one should be the close button,
|
||
// we want to skip it and choose the second one instead, which is the search box.
|
||
const searchBox = external_wp_dom_namespaceObject.focus.tabbable.find(contentContainer)[1];
|
||
|
||
if (searchBox) {
|
||
searchBox.focus();
|
||
}
|
||
}
|
||
|
||
});
|
||
}
|
||
}
|
||
|
||
close() {
|
||
if (this.expanded()) {
|
||
const contentContainer = this.contentContainer[0];
|
||
const activeElement = contentContainer.ownerDocument.activeElement;
|
||
this.isFromInternalAction = true;
|
||
this.collapse({
|
||
completeCallback() {
|
||
// Return back the focus when closing the inserter.
|
||
// Only do this if the active element which triggers the action is inside the inserter,
|
||
// (the close button for instance). In that case the focus will be lost.
|
||
// Otherwise, we don't hijack the focus when the user is focusing on other elements
|
||
// (like the quick inserter).
|
||
if (contentContainer.contains(activeElement)) {
|
||
// Return back the focus when closing the inserter.
|
||
if (this.activeElementBeforeExpanded) {
|
||
this.activeElementBeforeExpanded.focus();
|
||
}
|
||
}
|
||
}
|
||
|
||
});
|
||
}
|
||
}
|
||
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/sidebar-control.js
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
const getInserterId = controlId => `widgets-inserter-${controlId}`;
|
||
|
||
function getSidebarControl() {
|
||
const {
|
||
wp: {
|
||
customize
|
||
}
|
||
} = window;
|
||
return class SidebarControl extends customize.Control {
|
||
constructor() {
|
||
super(...arguments);
|
||
this.subscribers = new Set();
|
||
}
|
||
|
||
ready() {
|
||
const InserterOuterSection = getInserterOuterSection();
|
||
this.inserter = new InserterOuterSection(getInserterId(this.id), {});
|
||
customize.section.add(this.inserter);
|
||
this.sectionInstance = customize.section(this.section());
|
||
this.inspector = this.sectionInstance.inspector;
|
||
this.sidebarAdapter = new SidebarAdapter(this.setting, customize);
|
||
}
|
||
|
||
subscribe(callback) {
|
||
this.subscribers.add(callback);
|
||
return () => {
|
||
this.subscribers.delete(callback);
|
||
};
|
||
}
|
||
|
||
onChangeSectionExpanded(expanded, args) {
|
||
if (!args.unchanged) {
|
||
// Close the inserter when the section collapses.
|
||
if (!expanded) {
|
||
(0,external_wp_data_namespaceObject.dispatch)(store).setIsInserterOpened(false);
|
||
}
|
||
|
||
this.subscribers.forEach(subscriber => subscriber(expanded, args));
|
||
}
|
||
}
|
||
|
||
};
|
||
}
|
||
|
||
;// CONCATENATED MODULE: external ["wp","hooks"]
|
||
var external_wp_hooks_namespaceObject = window["wp"]["hooks"];
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/move-to-sidebar.js
|
||
|
||
|
||
/**
|
||
* External dependencies
|
||
*/
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
const withMoveToSidebarToolbarItem = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
|
||
let widgetId = (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(props);
|
||
const sidebarControls = useSidebarControls();
|
||
const activeSidebarControl = useActiveSidebarControl();
|
||
const hasMultipleSidebars = (sidebarControls === null || sidebarControls === void 0 ? void 0 : sidebarControls.length) > 1;
|
||
const blockName = props.name;
|
||
const clientId = props.clientId;
|
||
const canInsertBlockInSidebar = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
||
// Use an empty string to represent the root block list, which
|
||
// in the customizer editor represents a sidebar/widget area.
|
||
return select(external_wp_blockEditor_namespaceObject.store).canInsertBlockType(blockName, '');
|
||
}, [blockName]);
|
||
const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getBlock(clientId), [clientId]);
|
||
const {
|
||
removeBlock
|
||
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
|
||
const [, focusWidget] = useFocusControl();
|
||
|
||
function moveToSidebar(sidebarControlId) {
|
||
const newSidebarControl = sidebarControls.find(sidebarControl => sidebarControl.id === sidebarControlId);
|
||
|
||
if (widgetId) {
|
||
/**
|
||
* If there's a widgetId, move it to the other sidebar.
|
||
*/
|
||
const oldSetting = activeSidebarControl.setting;
|
||
const newSetting = newSidebarControl.setting;
|
||
oldSetting((0,external_lodash_namespaceObject.without)(oldSetting(), widgetId));
|
||
newSetting([...newSetting(), widgetId]);
|
||
} else {
|
||
/**
|
||
* If there isn't a widgetId, it's most likely a inner block.
|
||
* First, remove the block in the original sidebar,
|
||
* then, create a new widget in the new sidebar and get back its widgetId.
|
||
*/
|
||
const sidebarAdapter = newSidebarControl.sidebarAdapter;
|
||
removeBlock(clientId);
|
||
const addedWidgetIds = sidebarAdapter.setWidgets([...sidebarAdapter.getWidgets(), blockToWidget(block)]); // The last non-null id is the added widget's id.
|
||
|
||
widgetId = addedWidgetIds.reverse().find(id => !!id);
|
||
} // Move focus to the moved widget and expand the sidebar.
|
||
|
||
|
||
focusWidget(widgetId);
|
||
}
|
||
|
||
return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(BlockEdit, props), hasMultipleSidebars && canInsertBlockInSidebar && (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockControls, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_widgets_namespaceObject.MoveToWidgetArea, {
|
||
widgetAreas: sidebarControls.map(sidebarControl => ({
|
||
id: sidebarControl.id,
|
||
name: sidebarControl.params.label,
|
||
description: sidebarControl.params.description
|
||
})),
|
||
currentWidgetAreaId: activeSidebarControl === null || activeSidebarControl === void 0 ? void 0 : activeSidebarControl.id,
|
||
onSelect: moveToSidebar
|
||
})));
|
||
}, 'withMoveToSidebarToolbarItem');
|
||
(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/customize-widgets/block-edit', withMoveToSidebarToolbarItem);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-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/customize-widgets/build-module/filters/wide-widget-display.js
|
||
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
const {
|
||
wp: wide_widget_display_wp
|
||
} = window;
|
||
const withWideWidgetDisplay = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
|
||
var _wp$customize$Widgets, _wp$customize$Widgets2;
|
||
|
||
const {
|
||
idBase
|
||
} = props.attributes;
|
||
const isWide = (_wp$customize$Widgets = (_wp$customize$Widgets2 = wide_widget_display_wp.customize.Widgets.data.availableWidgets.find(widget => widget.id_base === idBase)) === null || _wp$customize$Widgets2 === void 0 ? void 0 : _wp$customize$Widgets2.is_wide) !== null && _wp$customize$Widgets !== void 0 ? _wp$customize$Widgets : false;
|
||
return (0,external_wp_element_namespaceObject.createElement)(BlockEdit, _extends({}, props, {
|
||
isWide: isWide
|
||
}));
|
||
}, 'withWideWidgetDisplay');
|
||
(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/customize-widgets/wide-widget-display', withWideWidgetDisplay);
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/index.js
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/index.js
|
||
|
||
|
||
/**
|
||
* WordPress dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Internal dependencies
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
const {
|
||
wp: build_module_wp
|
||
} = window;
|
||
const DISABLED_BLOCKS = ['core/more', 'core/block', 'core/freeform', 'core/template-part'];
|
||
const ENABLE_EXPERIMENTAL_FSE_BLOCKS = false;
|
||
/**
|
||
* Initializes the widgets block editor in the customizer.
|
||
*
|
||
* @param {string} editorName The editor name.
|
||
* @param {Object} blockEditorSettings Block editor settings.
|
||
*/
|
||
|
||
function initialize(editorName, blockEditorSettings) {
|
||
(0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults('core/customize-widgets', {
|
||
fixedToolbar: false,
|
||
welcomeGuide: true
|
||
});
|
||
|
||
(0,external_wp_data_namespaceObject.dispatch)(external_wp_blocks_namespaceObject.store).__experimentalReapplyBlockTypeFilters();
|
||
|
||
const coreBlocks = (0,external_wp_blockLibrary_namespaceObject.__experimentalGetCoreBlocks)().filter(block => {
|
||
return !(DISABLED_BLOCKS.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_blockLibrary_namespaceObject.registerCoreBlocks)(coreBlocks);
|
||
(0,external_wp_widgets_namespaceObject.registerLegacyWidgetBlock)();
|
||
|
||
if (false) {}
|
||
|
||
(0,external_wp_widgets_namespaceObject.registerLegacyWidgetVariations)(blockEditorSettings);
|
||
(0,external_wp_widgets_namespaceObject.registerWidgetGroupBlock)(); // 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');
|
||
const SidebarControl = getSidebarControl(blockEditorSettings);
|
||
build_module_wp.customize.sectionConstructor.sidebar = getSidebarSection();
|
||
build_module_wp.customize.controlConstructor.sidebar_block_editor = SidebarControl;
|
||
const container = document.createElement('div');
|
||
document.body.appendChild(container);
|
||
build_module_wp.customize.bind('ready', () => {
|
||
const sidebarControls = [];
|
||
build_module_wp.customize.control.each(control => {
|
||
if (control instanceof SidebarControl) {
|
||
sidebarControls.push(control);
|
||
}
|
||
});
|
||
(0,external_wp_element_namespaceObject.render)((0,external_wp_element_namespaceObject.createElement)(CustomizeWidgets, {
|
||
api: build_module_wp.customize,
|
||
sidebarControls: sidebarControls,
|
||
blockEditorSettings: blockEditorSettings
|
||
}), container);
|
||
});
|
||
}
|
||
|
||
}();
|
||
(window.wp = window.wp || {}).customizeWidgets = __webpack_exports__;
|
||
/******/ })()
|
||
; |