|
|
/******/ (() => { // webpackBootstrap
|
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
|
|
/***/ 5755:
|
|
|
/***/ ((module, exports) => {
|
|
|
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
|
|
|
Copyright (c) 2018 Jed Watson.
|
|
|
Licensed under the MIT License (MIT), see
|
|
|
http://jedwatson.github.io/classnames
|
|
|
*/
|
|
|
/* global define */
|
|
|
|
|
|
(function () {
|
|
|
'use strict';
|
|
|
|
|
|
var hasOwn = {}.hasOwnProperty;
|
|
|
var nativeCodeString = '[native code]';
|
|
|
|
|
|
function classNames() {
|
|
|
var classes = [];
|
|
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
|
var arg = arguments[i];
|
|
|
if (!arg) continue;
|
|
|
|
|
|
var argType = typeof arg;
|
|
|
|
|
|
if (argType === 'string' || argType === 'number') {
|
|
|
classes.push(arg);
|
|
|
} else if (Array.isArray(arg)) {
|
|
|
if (arg.length) {
|
|
|
var inner = classNames.apply(null, arg);
|
|
|
if (inner) {
|
|
|
classes.push(inner);
|
|
|
}
|
|
|
}
|
|
|
} else if (argType === 'object') {
|
|
|
if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
|
|
|
classes.push(arg.toString());
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
for (var key in arg) {
|
|
|
if (hasOwn.call(arg, key) && arg[key]) {
|
|
|
classes.push(key);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return classes.join(' ');
|
|
|
}
|
|
|
|
|
|
if ( true && module.exports) {
|
|
|
classNames.default = classNames;
|
|
|
module.exports = classNames;
|
|
|
} else if (true) {
|
|
|
// register as 'classnames', consistent with npm package name
|
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
|
|
|
return classNames;
|
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
|
} else {}
|
|
|
}());
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 7734:
|
|
|
/***/ ((module) => {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
// do not edit .js files directly - edit src/index.jst
|
|
|
|
|
|
|
|
|
var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
|
|
|
|
|
|
|
|
|
module.exports = function equal(a, b) {
|
|
|
if (a === b) return true;
|
|
|
|
|
|
if (a && b && typeof a == 'object' && typeof b == 'object') {
|
|
|
if (a.constructor !== b.constructor) return false;
|
|
|
|
|
|
var length, i, keys;
|
|
|
if (Array.isArray(a)) {
|
|
|
length = a.length;
|
|
|
if (length != b.length) return false;
|
|
|
for (i = length; i-- !== 0;)
|
|
|
if (!equal(a[i], b[i])) return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
if ((a instanceof Map) && (b instanceof Map)) {
|
|
|
if (a.size !== b.size) return false;
|
|
|
for (i of a.entries())
|
|
|
if (!b.has(i[0])) return false;
|
|
|
for (i of a.entries())
|
|
|
if (!equal(i[1], b.get(i[0]))) return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if ((a instanceof Set) && (b instanceof Set)) {
|
|
|
if (a.size !== b.size) return false;
|
|
|
for (i of a.entries())
|
|
|
if (!b.has(i[0])) return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
|
|
|
length = a.length;
|
|
|
if (length != b.length) return false;
|
|
|
for (i = length; i-- !== 0;)
|
|
|
if (a[i] !== b[i]) return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
|
|
|
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
|
|
|
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
|
|
|
|
|
|
keys = Object.keys(a);
|
|
|
length = keys.length;
|
|
|
if (length !== Object.keys(b).length) return false;
|
|
|
|
|
|
for (i = length; i-- !== 0;)
|
|
|
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
|
|
|
|
|
|
for (i = length; i-- !== 0;) {
|
|
|
var key = keys[i];
|
|
|
|
|
|
if (!equal(a[key], b[key])) return false;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// true if both NaN, false otherwise
|
|
|
return a!==a && b!==b;
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
|
|
/******/ });
|
|
|
/************************************************************************/
|
|
|
/******/ // The module cache
|
|
|
/******/ var __webpack_module_cache__ = {};
|
|
|
/******/
|
|
|
/******/ // The require function
|
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
/******/ // Check if module is in cache
|
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
|
/******/ if (cachedModule !== undefined) {
|
|
|
/******/ return cachedModule.exports;
|
|
|
/******/ }
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
|
/******/ // no module.id needed
|
|
|
/******/ // no module.loaded needed
|
|
|
/******/ exports: {}
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // Execute the module function
|
|
|
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
|
|
|
/******/
|
|
|
/******/ // Return the exports of the module
|
|
|
/******/ return module.exports;
|
|
|
/******/ }
|
|
|
/******/
|
|
|
/************************************************************************/
|
|
|
/******/ /* webpack/runtime/compat get default export */
|
|
|
/******/ (() => {
|
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
|
/******/ __webpack_require__.n = (module) => {
|
|
|
/******/ var getter = module && module.__esModule ?
|
|
|
/******/ () => (module['default']) :
|
|
|
/******/ () => (module);
|
|
|
/******/ __webpack_require__.d(getter, { a: getter });
|
|
|
/******/ return getter;
|
|
|
/******/ };
|
|
|
/******/ })();
|
|
|
/******/
|
|
|
/******/ /* webpack/runtime/define property getters */
|
|
|
/******/ (() => {
|
|
|
/******/ // define getter functions for harmony exports
|
|
|
/******/ __webpack_require__.d = (exports, definition) => {
|
|
|
/******/ for(var key in definition) {
|
|
|
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
|
|
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
|
|
/******/ }
|
|
|
/******/ }
|
|
|
/******/ };
|
|
|
/******/ })();
|
|
|
/******/
|
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
|
/******/ (() => {
|
|
|
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
|
|
|
/******/ })();
|
|
|
/******/
|
|
|
/******/ /* webpack/runtime/make namespace object */
|
|
|
/******/ (() => {
|
|
|
/******/ // define __esModule on exports
|
|
|
/******/ __webpack_require__.r = (exports) => {
|
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
|
/******/ }
|
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
/******/ };
|
|
|
/******/ })();
|
|
|
/******/
|
|
|
/************************************************************************/
|
|
|
var __webpack_exports__ = {};
|
|
|
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
|
|
|
(() => {
|
|
|
"use strict";
|
|
|
// ESM COMPAT FLAG
|
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
initialize: () => (/* binding */ initialize),
|
|
|
store: () => (/* reexport */ store)
|
|
|
});
|
|
|
|
|
|
// 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: () => (__experimentalGetInsertionPoint),
|
|
|
isInserterOpened: () => (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: () => (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, {
|
|
|
closeModal: () => (closeModal),
|
|
|
disableComplementaryArea: () => (disableComplementaryArea),
|
|
|
enableComplementaryArea: () => (enableComplementaryArea),
|
|
|
openModal: () => (openModal),
|
|
|
pinItem: () => (pinItem),
|
|
|
setDefaultComplementaryArea: () => (setDefaultComplementaryArea),
|
|
|
setFeatureDefaults: () => (setFeatureDefaults),
|
|
|
setFeatureValue: () => (setFeatureValue),
|
|
|
toggleFeature: () => (toggleFeature),
|
|
|
unpinItem: () => (unpinItem)
|
|
|
});
|
|
|
|
|
|
// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/selectors.js
|
|
|
var store_selectors_namespaceObject = {};
|
|
|
__webpack_require__.r(store_selectors_namespaceObject);
|
|
|
__webpack_require__.d(store_selectors_namespaceObject, {
|
|
|
getActiveComplementaryArea: () => (getActiveComplementaryArea),
|
|
|
isComplementaryAreaLoading: () => (isComplementaryAreaLoading),
|
|
|
isFeatureActive: () => (isFeatureActive),
|
|
|
isItemPinned: () => (isItemPinned),
|
|
|
isModalActive: () => (isModalActive)
|
|
|
});
|
|
|
|
|
|
;// CONCATENATED MODULE: external "React"
|
|
|
const external_React_namespaceObject = window["React"];
|
|
|
;// CONCATENATED MODULE: external ["wp","element"]
|
|
|
const external_wp_element_namespaceObject = window["wp"]["element"];
|
|
|
;// CONCATENATED MODULE: external ["wp","blockLibrary"]
|
|
|
const external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
|
|
|
;// CONCATENATED MODULE: external ["wp","widgets"]
|
|
|
const external_wp_widgets_namespaceObject = window["wp"]["widgets"];
|
|
|
;// CONCATENATED MODULE: external ["wp","blocks"]
|
|
|
const external_wp_blocks_namespaceObject = window["wp"]["blocks"];
|
|
|
;// CONCATENATED MODULE: external ["wp","data"]
|
|
|
const external_wp_data_namespaceObject = window["wp"]["data"];
|
|
|
;// CONCATENATED MODULE: external ["wp","preferences"]
|
|
|
const external_wp_preferences_namespaceObject = window["wp"]["preferences"];
|
|
|
;// CONCATENATED MODULE: external ["wp","components"]
|
|
|
const external_wp_components_namespaceObject = window["wp"]["components"];
|
|
|
;// CONCATENATED MODULE: external ["wp","i18n"]
|
|
|
const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
|
|
|
;// CONCATENATED MODULE: external ["wp","blockEditor"]
|
|
|
const external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
|
|
|
;// CONCATENATED MODULE: external ["wp","compose"]
|
|
|
const external_wp_compose_namespaceObject = window["wp"]["compose"];
|
|
|
;// CONCATENATED MODULE: external ["wp","hooks"]
|
|
|
const external_wp_hooks_namespaceObject = window["wp"]["hooks"];
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/error-boundary/index.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function CopyButton({
|
|
|
text,
|
|
|
children
|
|
|
}) {
|
|
|
const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(text);
|
|
|
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
|
|
|
variant: "secondary",
|
|
|
ref: ref
|
|
|
}, children);
|
|
|
}
|
|
|
class ErrorBoundary extends external_wp_element_namespaceObject.Component {
|
|
|
constructor() {
|
|
|
super(...arguments);
|
|
|
this.state = {
|
|
|
error: null
|
|
|
};
|
|
|
}
|
|
|
componentDidCatch(error) {
|
|
|
this.setState({
|
|
|
error
|
|
|
});
|
|
|
(0,external_wp_hooks_namespaceObject.doAction)('editor.ErrorBoundary.errorLogged', error);
|
|
|
}
|
|
|
render() {
|
|
|
const {
|
|
|
error
|
|
|
} = this.state;
|
|
|
if (!error) {
|
|
|
return this.props.children;
|
|
|
}
|
|
|
return (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.Warning, {
|
|
|
className: "customize-widgets-error-boundary",
|
|
|
actions: [(0,external_React_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 ["wp","coreData"]
|
|
|
const external_wp_coreData_namespaceObject = window["wp"]["coreData"];
|
|
|
;// CONCATENATED MODULE: external ["wp","mediaUtils"]
|
|
|
const external_wp_mediaUtils_namespaceObject = window["wp"]["mediaUtils"];
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/block-inspector-button/index.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function BlockInspectorButton({
|
|
|
inspector,
|
|
|
closeMenu,
|
|
|
...props
|
|
|
}) {
|
|
|
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
|
|
|
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 */ const block_inspector_button = (BlockInspectorButton);
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
|
var classnames = __webpack_require__(5755);
|
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
|
;// CONCATENATED MODULE: external ["wp","keycodes"]
|
|
|
const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
|
|
|
;// CONCATENATED MODULE: external ["wp","primitives"]
|
|
|
const external_wp_primitives_namespaceObject = window["wp"]["primitives"];
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/undo.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const undo = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M18.3 11.7c-.6-.6-1.4-.9-2.3-.9H6.7l2.9-3.3-1.1-1-4.5 5L8.5 16l1-1-2.7-2.7H16c.5 0 .9.2 1.3.5 1 1 1 3.4 1 4.5v.3h1.5v-.2c0-1.5 0-4.3-1.5-5.7z"
|
|
|
}));
|
|
|
/* harmony default export */ const library_undo = (undo);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/redo.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const redo = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M15.6 6.5l-1.1 1 2.9 3.3H8c-.9 0-1.7.3-2.3.9-1.4 1.5-1.4 4.2-1.4 5.6v.2h1.5v-.3c0-1.1 0-3.5 1-4.5.3-.3.7-.5 1.3-.5h9.2L14.5 15l1.1 1.1 4.6-4.6-4.6-5z"
|
|
|
}));
|
|
|
/* harmony default export */ const library_redo = (redo);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plus.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const plus = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z"
|
|
|
}));
|
|
|
/* harmony default export */ const library_plus = (plus);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close-small.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const closeSmall = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z"
|
|
|
}));
|
|
|
/* harmony default export */ const close_small = (closeSmall);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/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(state = false, action) {
|
|
|
switch (action.type) {
|
|
|
case 'SET_IS_INSERTER_OPENED':
|
|
|
return action.value;
|
|
|
}
|
|
|
return state;
|
|
|
}
|
|
|
/* harmony default export */ const reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
|
|
|
blockInserterPanel
|
|
|
}));
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/selectors.js
|
|
|
const EMPTY_INSERTION_POINT = {
|
|
|
rootClientId: undefined,
|
|
|
insertionIndex: undefined
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns true if the inserter is opened.
|
|
|
*
|
|
|
* @param {Object} state Global application state.
|
|
|
*
|
|
|
* @example
|
|
|
* ```js
|
|
|
* import { store as customizeWidgetsStore } from '@wordpress/customize-widgets';
|
|
|
* import { __ } from '@wordpress/i18n';
|
|
|
* import { useSelect } from '@wordpress/data';
|
|
|
*
|
|
|
* const ExampleComponent = () => {
|
|
|
* const { isInserterOpened } = useSelect(
|
|
|
* ( select ) => select( customizeWidgetsStore ),
|
|
|
* []
|
|
|
* );
|
|
|
*
|
|
|
* return isInserterOpened()
|
|
|
* ? __( 'Inserter is open' )
|
|
|
* : __( 'Inserter is closed.' );
|
|
|
* };
|
|
|
* ```
|
|
|
*
|
|
|
* @return {boolean} Whether the inserter is opened.
|
|
|
*/
|
|
|
function isInserterOpened(state) {
|
|
|
return !!state.blockInserterPanel;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Get the insertion point for the inserter.
|
|
|
*
|
|
|
* @param {Object} state Global application state.
|
|
|
*
|
|
|
* @return {Object} The root client ID and index to insert at.
|
|
|
*/
|
|
|
function __experimentalGetInsertionPoint(state) {
|
|
|
if (typeof state.blockInserterPanel === 'boolean') {
|
|
|
return EMPTY_INSERTION_POINT;
|
|
|
}
|
|
|
return state.blockInserterPanel;
|
|
|
}
|
|
|
|
|
|
;// 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.
|
|
|
*
|
|
|
* @example
|
|
|
* ```js
|
|
|
* import { useState } from 'react';
|
|
|
* import { store as customizeWidgetsStore } from '@wordpress/customize-widgets';
|
|
|
* import { __ } from '@wordpress/i18n';
|
|
|
* import { useDispatch } from '@wordpress/data';
|
|
|
* import { Button } from '@wordpress/components';
|
|
|
*
|
|
|
* const ExampleComponent = () => {
|
|
|
* const { setIsInserterOpened } = useDispatch( customizeWidgetsStore );
|
|
|
* const [ isOpen, setIsOpen ] = useState( false );
|
|
|
*
|
|
|
* return (
|
|
|
* <Button
|
|
|
* onClick={ () => {
|
|
|
* setIsInserterOpened( ! isOpen );
|
|
|
* setIsOpen( ! isOpen );
|
|
|
* } }
|
|
|
* >
|
|
|
* { __( 'Open/close inserter' ) }
|
|
|
* </Button>
|
|
|
* );
|
|
|
* };
|
|
|
* ```
|
|
|
*
|
|
|
* @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({
|
|
|
setIsOpened
|
|
|
}) {
|
|
|
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_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-layout__inserter-panel",
|
|
|
"aria-labelledby": inserterTitleId
|
|
|
}, (0,external_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-layout__inserter-panel-header"
|
|
|
}, (0,external_React_namespaceObject.createElement)("h2", {
|
|
|
id: inserterTitleId,
|
|
|
className: "customize-widgets-layout__inserter-panel-header-title"
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Add a block')), (0,external_React_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_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-layout__inserter-panel-content"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__experimentalLibrary, {
|
|
|
rootClientId: insertionPoint.rootClientId,
|
|
|
__experimentalInsertionIndex: insertionPoint.insertionIndex,
|
|
|
showInserterHelpPanel: true,
|
|
|
onSelect: () => setIsOpened(false)
|
|
|
})));
|
|
|
}
|
|
|
/* harmony default export */ const components_inserter = (Inserter);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/external.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const external = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M19.5 4.5h-7V6h4.44l-5.97 5.97 1.06 1.06L18 7.06v4.44h1.5v-7Zm-13 1a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-3H17v3a.5.5 0 0 1-.5.5h-10a.5.5 0 0 1-.5-.5v-10a.5.5 0 0 1 .5-.5h3V5.5h-3Z"
|
|
|
}));
|
|
|
/* harmony default export */ const library_external = (external);
|
|
|
|
|
|
;// CONCATENATED MODULE: external ["wp","keyboardShortcuts"]
|
|
|
const external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const moreVertical = (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
|
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
|
viewBox: "0 0 24 24"
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
|
|
|
d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
|
|
|
}));
|
|
|
/* harmony default export */ const more_vertical = (moreVertical);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/more-menu-dropdown/index.js
|
|
|
|
|
|
/**
|
|
|
* External dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
function MoreMenuDropdown({
|
|
|
as: DropdownComponent = external_wp_components_namespaceObject.DropdownMenu,
|
|
|
className,
|
|
|
/* translators: button label text should, if possible, be under 16 characters. */
|
|
|
label = (0,external_wp_i18n_namespaceObject.__)('Options'),
|
|
|
popoverProps,
|
|
|
toggleProps,
|
|
|
children
|
|
|
}) {
|
|
|
return (0,external_React_namespaceObject.createElement)(DropdownComponent, {
|
|
|
className: classnames_default()('interface-more-menu-dropdown', className),
|
|
|
icon: more_vertical,
|
|
|
label: label,
|
|
|
popoverProps: {
|
|
|
placement: 'bottom-end',
|
|
|
...popoverProps,
|
|
|
className: classnames_default()('interface-more-menu-dropdown__content', popoverProps?.className)
|
|
|
},
|
|
|
toggleProps: {
|
|
|
tooltipPosition: 'bottom',
|
|
|
...toggleProps,
|
|
|
size: 'compact'
|
|
|
}
|
|
|
}, onClose => children(onClose));
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: external ["wp","deprecated"]
|
|
|
const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
|
|
|
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/actions.js
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Set a default complementary area.
|
|
|
*
|
|
|
* @param {string} scope Complementary area scope.
|
|
|
* @param {string} area Area identifier.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
const setDefaultComplementaryArea = (scope, area) => ({
|
|
|
type: 'SET_DEFAULT_COMPLEMENTARY_AREA',
|
|
|
scope,
|
|
|
area
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* Enable the complementary area.
|
|
|
*
|
|
|
* @param {string} scope Complementary area scope.
|
|
|
* @param {string} area Area identifier.
|
|
|
*/
|
|
|
const enableComplementaryArea = (scope, area) => ({
|
|
|
registry,
|
|
|
dispatch
|
|
|
}) => {
|
|
|
// Return early if there's no area.
|
|
|
if (!area) {
|
|
|
return;
|
|
|
}
|
|
|
const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
|
|
|
if (!isComplementaryAreaVisible) {
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', true);
|
|
|
}
|
|
|
dispatch({
|
|
|
type: 'ENABLE_COMPLEMENTARY_AREA',
|
|
|
scope,
|
|
|
area
|
|
|
});
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Disable the complementary area.
|
|
|
*
|
|
|
* @param {string} scope Complementary area scope.
|
|
|
*/
|
|
|
const disableComplementaryArea = scope => ({
|
|
|
registry
|
|
|
}) => {
|
|
|
const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
|
|
|
if (isComplementaryAreaVisible) {
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', false);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Pins an item.
|
|
|
*
|
|
|
* @param {string} scope Item scope.
|
|
|
* @param {string} item Item identifier.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
const pinItem = (scope, item) => ({
|
|
|
registry
|
|
|
}) => {
|
|
|
// Return early if there's no item.
|
|
|
if (!item) {
|
|
|
return;
|
|
|
}
|
|
|
const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
|
|
|
|
|
|
// The item is already pinned, there's nothing to do.
|
|
|
if (pinnedItems?.[item] === true) {
|
|
|
return;
|
|
|
}
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
|
|
|
...pinnedItems,
|
|
|
[item]: true
|
|
|
});
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Unpins an item.
|
|
|
*
|
|
|
* @param {string} scope Item scope.
|
|
|
* @param {string} item Item identifier.
|
|
|
*/
|
|
|
const unpinItem = (scope, item) => ({
|
|
|
registry
|
|
|
}) => {
|
|
|
// Return early if there's no item.
|
|
|
if (!item) {
|
|
|
return;
|
|
|
}
|
|
|
const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
|
|
|
...pinnedItems,
|
|
|
[item]: false
|
|
|
});
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns an action object used in signalling that a feature should be toggled.
|
|
|
*
|
|
|
* @param {string} scope The feature scope (e.g. core/edit-post).
|
|
|
* @param {string} featureName The feature name.
|
|
|
*/
|
|
|
function toggleFeature(scope, featureName) {
|
|
|
return function ({
|
|
|
registry
|
|
|
}) {
|
|
|
external_wp_deprecated_default()(`dispatch( 'core/interface' ).toggleFeature`, {
|
|
|
since: '6.0',
|
|
|
alternative: `dispatch( 'core/preferences' ).toggle`
|
|
|
});
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(scope, featureName);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns an action object used in signalling that a feature should be set to
|
|
|
* a true or false value
|
|
|
*
|
|
|
* @param {string} scope The feature scope (e.g. core/edit-post).
|
|
|
* @param {string} featureName The feature name.
|
|
|
* @param {boolean} value The value to set.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
function setFeatureValue(scope, featureName, value) {
|
|
|
return function ({
|
|
|
registry
|
|
|
}) {
|
|
|
external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureValue`, {
|
|
|
since: '6.0',
|
|
|
alternative: `dispatch( 'core/preferences' ).set`
|
|
|
});
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, featureName, !!value);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns an action object used in signalling that defaults should be set for features.
|
|
|
*
|
|
|
* @param {string} scope The feature scope (e.g. core/edit-post).
|
|
|
* @param {Object<string, boolean>} defaults A key/value map of feature names to values.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
function setFeatureDefaults(scope, defaults) {
|
|
|
return function ({
|
|
|
registry
|
|
|
}) {
|
|
|
external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureDefaults`, {
|
|
|
since: '6.0',
|
|
|
alternative: `dispatch( 'core/preferences' ).setDefaults`
|
|
|
});
|
|
|
registry.dispatch(external_wp_preferences_namespaceObject.store).setDefaults(scope, defaults);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns an action object used in signalling that the user opened a modal.
|
|
|
*
|
|
|
* @param {string} name A string that uniquely identifies the modal.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
function openModal(name) {
|
|
|
return {
|
|
|
type: 'OPEN_MODAL',
|
|
|
name
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns an action object signalling that the user closed a modal.
|
|
|
*
|
|
|
* @return {Object} Action object.
|
|
|
*/
|
|
|
function closeModal() {
|
|
|
return {
|
|
|
type: 'CLOSE_MODAL'
|
|
|
};
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/selectors.js
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Returns the complementary area that is active in a given scope.
|
|
|
*
|
|
|
* @param {Object} state Global application state.
|
|
|
* @param {string} scope Item scope.
|
|
|
*
|
|
|
* @return {string | null | undefined} The complementary area that is active in the given scope.
|
|
|
*/
|
|
|
const getActiveComplementaryArea = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
|
|
|
const isComplementaryAreaVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
|
|
|
|
|
|
// Return `undefined` to indicate that the user has never toggled
|
|
|
// visibility, this is the vanilla default. Other code relies on this
|
|
|
// nuance in the return value.
|
|
|
if (isComplementaryAreaVisible === undefined) {
|
|
|
return undefined;
|
|
|
}
|
|
|
|
|
|
// Return `null` to indicate the user hid the complementary area.
|
|
|
if (isComplementaryAreaVisible === false) {
|
|
|
return null;
|
|
|
}
|
|
|
return state?.complementaryAreas?.[scope];
|
|
|
});
|
|
|
const isComplementaryAreaLoading = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
|
|
|
const isVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
|
|
|
const identifier = state?.complementaryAreas?.[scope];
|
|
|
return isVisible && identifier === undefined;
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* Returns a boolean indicating if an item is pinned or not.
|
|
|
*
|
|
|
* @param {Object} state Global application state.
|
|
|
* @param {string} scope Scope.
|
|
|
* @param {string} item Item to check.
|
|
|
*
|
|
|
* @return {boolean} True if the item is pinned and false otherwise.
|
|
|
*/
|
|
|
const isItemPinned = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, item) => {
|
|
|
var _pinnedItems$item;
|
|
|
const pinnedItems = select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
|
|
|
return (_pinnedItems$item = pinnedItems?.[item]) !== null && _pinnedItems$item !== void 0 ? _pinnedItems$item : true;
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* Returns a boolean indicating whether a feature is active for a particular
|
|
|
* scope.
|
|
|
*
|
|
|
* @param {Object} state The store state.
|
|
|
* @param {string} scope The scope of the feature (e.g. core/edit-post).
|
|
|
* @param {string} featureName The name of the feature.
|
|
|
*
|
|
|
* @return {boolean} Is the feature enabled?
|
|
|
*/
|
|
|
const isFeatureActive = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, featureName) => {
|
|
|
external_wp_deprecated_default()(`select( 'core/interface' ).isFeatureActive( scope, featureName )`, {
|
|
|
since: '6.0',
|
|
|
alternative: `select( 'core/preferences' ).get( scope, featureName )`
|
|
|
});
|
|
|
return !!select(external_wp_preferences_namespaceObject.store).get(scope, featureName);
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* Returns true if a modal is active, or false otherwise.
|
|
|
*
|
|
|
* @param {Object} state Global application state.
|
|
|
* @param {string} modalName A string that uniquely identifies the modal.
|
|
|
*
|
|
|
* @return {boolean} Whether the modal is active.
|
|
|
*/
|
|
|
function isModalActive(state, modalName) {
|
|
|
return state.activeModal === modalName;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/reducer.js
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
function complementaryAreas(state = {}, action) {
|
|
|
switch (action.type) {
|
|
|
case 'SET_DEFAULT_COMPLEMENTARY_AREA':
|
|
|
{
|
|
|
const {
|
|
|
scope,
|
|
|
area
|
|
|
} = action;
|
|
|
|
|
|
// If there's already an area, don't overwrite it.
|
|
|
if (state[scope]) {
|
|
|
return state;
|
|
|
}
|
|
|
return {
|
|
|
...state,
|
|
|
[scope]: area
|
|
|
};
|
|
|
}
|
|
|
case 'ENABLE_COMPLEMENTARY_AREA':
|
|
|
{
|
|
|
const {
|
|
|
scope,
|
|
|
area
|
|
|
} = action;
|
|
|
return {
|
|
|
...state,
|
|
|
[scope]: area
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
return state;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Reducer for storing the name of the open modal, or null if no modal is open.
|
|
|
*
|
|
|
* @param {Object} state Previous state.
|
|
|
* @param {Object} action Action object containing the `name` of the modal
|
|
|
*
|
|
|
* @return {Object} Updated state
|
|
|
*/
|
|
|
function activeModal(state = null, action) {
|
|
|
switch (action.type) {
|
|
|
case 'OPEN_MODAL':
|
|
|
return action.name;
|
|
|
case 'CLOSE_MODAL':
|
|
|
return null;
|
|
|
}
|
|
|
return state;
|
|
|
}
|
|
|
/* harmony default export */ const store_reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
|
|
|
complementaryAreas,
|
|
|
activeModal
|
|
|
}));
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/constants.js
|
|
|
/**
|
|
|
* The identifier for the data store.
|
|
|
*
|
|
|
* @type {string}
|
|
|
*/
|
|
|
const 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: store_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: {
|
|
|
character: '[['
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Insert a link to a post or page.')
|
|
|
}, {
|
|
|
keyCombination: {
|
|
|
modifier: 'primary',
|
|
|
character: 'u'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Underline the selected text.')
|
|
|
}, {
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: 'd'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Strikethrough the selected text.')
|
|
|
}, {
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: 'x'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text inline code.')
|
|
|
}, {
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: '0'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Convert the current heading to a paragraph.')
|
|
|
}, {
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: '1-6'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Convert the current paragraph or heading to a heading of level 1 to 6.')
|
|
|
}];
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/shortcut.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
function KeyCombination({
|
|
|
keyCombination,
|
|
|
forceAriaLabel
|
|
|
}) {
|
|
|
const shortcut = keyCombination.modifier ? external_wp_keycodes_namespaceObject.displayShortcutList[keyCombination.modifier](keyCombination.character) : keyCombination.character;
|
|
|
const ariaLabel = keyCombination.modifier ? external_wp_keycodes_namespaceObject.shortcutAriaLabel[keyCombination.modifier](keyCombination.character) : keyCombination.character;
|
|
|
return (0,external_React_namespaceObject.createElement)("kbd", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key-combination",
|
|
|
"aria-label": forceAriaLabel || ariaLabel
|
|
|
}, (Array.isArray(shortcut) ? shortcut : [shortcut]).map((character, index) => {
|
|
|
if (character === '+') {
|
|
|
return (0,external_React_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, {
|
|
|
key: index
|
|
|
}, character);
|
|
|
}
|
|
|
return (0,external_React_namespaceObject.createElement)("kbd", {
|
|
|
key: index,
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key"
|
|
|
}, character);
|
|
|
}));
|
|
|
}
|
|
|
function Shortcut({
|
|
|
description,
|
|
|
keyCombination,
|
|
|
aliases = [],
|
|
|
ariaLabel
|
|
|
}) {
|
|
|
return (0,external_React_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-description"
|
|
|
}, description), (0,external_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-term"
|
|
|
}, (0,external_React_namespaceObject.createElement)(KeyCombination, {
|
|
|
keyCombination: keyCombination,
|
|
|
forceAriaLabel: ariaLabel
|
|
|
}), aliases.map((alias, index) => (0,external_React_namespaceObject.createElement)(KeyCombination, {
|
|
|
keyCombination: alias,
|
|
|
forceAriaLabel: ariaLabel,
|
|
|
key: index
|
|
|
}))));
|
|
|
}
|
|
|
/* harmony default export */ const keyboard_shortcut_help_modal_shortcut = (Shortcut);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/dynamic-shortcut.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Internal dependencies
|
|
|
*/
|
|
|
|
|
|
function DynamicShortcut({
|
|
|
name
|
|
|
}) {
|
|
|
const {
|
|
|
keyCombination,
|
|
|
description,
|
|
|
aliases
|
|
|
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
|
|
const {
|
|
|
getShortcutKeyCombination,
|
|
|
getShortcutDescription,
|
|
|
getShortcutAliases
|
|
|
} = select(external_wp_keyboardShortcuts_namespaceObject.store);
|
|
|
return {
|
|
|
keyCombination: getShortcutKeyCombination(name),
|
|
|
aliases: getShortcutAliases(name),
|
|
|
description: getShortcutDescription(name)
|
|
|
};
|
|
|
}, [name]);
|
|
|
if (!keyCombination) {
|
|
|
return null;
|
|
|
}
|
|
|
return (0,external_React_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
|
|
|
keyCombination: keyCombination,
|
|
|
description: description,
|
|
|
aliases: aliases
|
|
|
});
|
|
|
}
|
|
|
/* harmony default export */ const dynamic_shortcut = (DynamicShortcut);
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/index.js
|
|
|
|
|
|
/**
|
|
|
* External dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Internal dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
const ShortcutList = ({
|
|
|
shortcuts
|
|
|
}) =>
|
|
|
/*
|
|
|
* Disable reason: The `list` ARIA role is redundant but
|
|
|
* Safari+VoiceOver won't announce the list otherwise.
|
|
|
*/
|
|
|
/* eslint-disable jsx-a11y/no-redundant-roles */
|
|
|
(0,external_React_namespaceObject.createElement)("ul", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-list",
|
|
|
role: "list"
|
|
|
}, shortcuts.map((shortcut, index) => (0,external_React_namespaceObject.createElement)("li", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__shortcut",
|
|
|
key: index
|
|
|
}, typeof shortcut === 'string' ? (0,external_React_namespaceObject.createElement)(dynamic_shortcut, {
|
|
|
name: shortcut
|
|
|
}) : (0,external_React_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
|
|
|
...shortcut
|
|
|
}))))
|
|
|
/* eslint-enable jsx-a11y/no-redundant-roles */;
|
|
|
const ShortcutSection = ({
|
|
|
title,
|
|
|
shortcuts,
|
|
|
className
|
|
|
}) => (0,external_React_namespaceObject.createElement)("section", {
|
|
|
className: classnames_default()('customize-widgets-keyboard-shortcut-help-modal__section', className)
|
|
|
}, !!title && (0,external_React_namespaceObject.createElement)("h2", {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__section-title"
|
|
|
}, title), (0,external_React_namespaceObject.createElement)(ShortcutList, {
|
|
|
shortcuts: shortcuts
|
|
|
}));
|
|
|
const ShortcutCategorySection = ({
|
|
|
title,
|
|
|
categoryName,
|
|
|
additionalShortcuts = []
|
|
|
}) => {
|
|
|
const categoryShortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
|
|
return select(external_wp_keyboardShortcuts_namespaceObject.store).getCategoryShortcuts(categoryName);
|
|
|
}, [categoryName]);
|
|
|
return (0,external_React_namespaceObject.createElement)(ShortcutSection, {
|
|
|
title: title,
|
|
|
shortcuts: categoryShortcuts.concat(additionalShortcuts)
|
|
|
});
|
|
|
};
|
|
|
function KeyboardShortcutHelpModal({
|
|
|
isModalActive,
|
|
|
toggleModal
|
|
|
}) {
|
|
|
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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Modal, {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal",
|
|
|
title: (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts'),
|
|
|
onRequestClose: toggleModal
|
|
|
}, (0,external_React_namespaceObject.createElement)(ShortcutSection, {
|
|
|
className: "customize-widgets-keyboard-shortcut-help-modal__main-shortcuts",
|
|
|
shortcuts: ['core/customize-widgets/keyboard-shortcuts']
|
|
|
}), (0,external_React_namespaceObject.createElement)(ShortcutCategorySection, {
|
|
|
title: (0,external_wp_i18n_namespaceObject.__)('Global shortcuts'),
|
|
|
categoryName: "global"
|
|
|
}), (0,external_React_namespaceObject.createElement)(ShortcutCategorySection, {
|
|
|
title: (0,external_wp_i18n_namespaceObject.__)('Selection shortcuts'),
|
|
|
categoryName: "selection"
|
|
|
}), (0,external_React_namespaceObject.createElement)(ShortcutCategorySection, {
|
|
|
title: (0,external_wp_i18n_namespaceObject.__)('Block shortcuts'),
|
|
|
categoryName: "block",
|
|
|
additionalShortcuts: [{
|
|
|
keyCombination: {
|
|
|
character: '/'
|
|
|
},
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Change the block type after adding a new paragraph.'),
|
|
|
/* translators: The forward-slash character. e.g. '/'. */
|
|
|
ariaLabel: (0,external_wp_i18n_namespaceObject.__)('Forward-slash')
|
|
|
}]
|
|
|
}), (0,external_React_namespaceObject.createElement)(ShortcutSection, {
|
|
|
title: (0,external_wp_i18n_namespaceObject.__)('Text formatting'),
|
|
|
shortcuts: textFormattingShortcuts
|
|
|
}));
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(MoreMenuDropdown, {
|
|
|
as: external_wp_components_namespaceObject.ToolbarDropdownMenu
|
|
|
}, () => (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
|
|
label: (0,external_wp_i18n_namespaceObject._x)('View', 'noun')
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
|
|
|
scope: "core/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_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
|
|
label: (0,external_wp_i18n_namespaceObject.__)('Tools')
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
|
|
|
onClick: () => {
|
|
|
setIsKeyboardShortcutsModalVisible(true);
|
|
|
},
|
|
|
shortcut: external_wp_keycodes_namespaceObject.displayShortcut.access('h')
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts')), (0,external_React_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
|
|
|
scope: "core/customize-widgets",
|
|
|
name: "welcomeGuide",
|
|
|
label: (0,external_wp_i18n_namespaceObject.__)('Welcome Guide')
|
|
|
}), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
|
|
|
role: "menuitem",
|
|
|
icon: library_external,
|
|
|
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/block-based-widgets-editor/'),
|
|
|
target: "_blank",
|
|
|
rel: "noopener noreferrer"
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Help'), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
|
|
|
as: "span"
|
|
|
}, /* translators: accessibility text */
|
|
|
(0,external_wp_i18n_namespaceObject.__)('(opens in a new tab)')))), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
|
|
|
label: (0,external_wp_i18n_namespaceObject.__)('Preferences')
|
|
|
}, (0,external_React_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_React_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({
|
|
|
sidebar,
|
|
|
inserter,
|
|
|
isInserterOpened,
|
|
|
setIsInserterOpened,
|
|
|
isFixedToolbarActive
|
|
|
}) {
|
|
|
const [[hasUndo, hasRedo], setUndoRedo] = (0,external_wp_element_namespaceObject.useState)([sidebar.hasUndo(), sidebar.hasRedo()]);
|
|
|
const shortcut = (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? external_wp_keycodes_namespaceObject.displayShortcut.primaryShift('z') : external_wp_keycodes_namespaceObject.displayShortcut.primary('y');
|
|
|
(0,external_wp_element_namespaceObject.useEffect)(() => {
|
|
|
return sidebar.subscribeHistory(() => {
|
|
|
setUndoRedo([sidebar.hasUndo(), sidebar.hasRedo()]);
|
|
|
});
|
|
|
}, [sidebar]);
|
|
|
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)("div", {
|
|
|
className: classnames_default()('customize-widgets-header', {
|
|
|
'is-fixed-toolbar-active': isFixedToolbarActive
|
|
|
})
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.NavigableToolbar, {
|
|
|
className: "customize-widgets-header-toolbar",
|
|
|
"aria-label": (0,external_wp_i18n_namespaceObject.__)('Document tools')
|
|
|
}, (0,external_React_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_React_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: shortcut
|
|
|
// If there are no undo levels we don't want to actually disable this
|
|
|
// button, because it will remove focus for keyboard users.
|
|
|
// See: https://github.com/WordPress/gutenberg/issues/3486
|
|
|
,
|
|
|
"aria-disabled": !hasRedo,
|
|
|
onClick: sidebar.redo,
|
|
|
className: "customize-widgets-editor-history-button redo-button"
|
|
|
}), (0,external_React_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_React_namespaceObject.createElement)(MoreMenu, null))), (0,external_wp_element_namespaceObject.createPortal)((0,external_React_namespaceObject.createElement)(components_inserter, {
|
|
|
setIsOpened: setIsInserterOpened
|
|
|
}), inserter.contentContainer[0]));
|
|
|
}
|
|
|
/* harmony default export */ const 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])];
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
|
|
|
var es6 = __webpack_require__(7734);
|
|
|
var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
|
|
|
;// CONCATENATED MODULE: external ["wp","isShallowEqual"]
|
|
|
const 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
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 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, existingWidget = 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?.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
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
const {
|
|
|
form,
|
|
|
rendered,
|
|
|
...restExistingWidget
|
|
|
} = existingWidget || {};
|
|
|
return {
|
|
|
...restExistingWidget,
|
|
|
...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({
|
|
|
id,
|
|
|
idBase,
|
|
|
number,
|
|
|
instance
|
|
|
}) {
|
|
|
let block;
|
|
|
const {
|
|
|
encoded_serialized_instance: encoded,
|
|
|
instance_hash_key: hash,
|
|
|
raw_instance: raw,
|
|
|
...rest
|
|
|
} = instance;
|
|
|
if (idBase === 'block') {
|
|
|
var _raw$content;
|
|
|
const parsedBlocks = (0,external_wp_blocks_namespaceObject.parse)((_raw$content = raw.content) !== null && _raw$content !== void 0 ? _raw$content : '', {
|
|
|
__unstableSkipAutop: true
|
|
|
});
|
|
|
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 (es6_default()(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({
|
|
|
api,
|
|
|
sidebarControls,
|
|
|
children
|
|
|
}) {
|
|
|
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);
|
|
|
}
|
|
|
let previewBound = false;
|
|
|
function handleReady() {
|
|
|
api.previewer.preview.bind('focus-control-for-setting', handleFocus);
|
|
|
previewBound = true;
|
|
|
}
|
|
|
api.previewer.bind('ready', handleReady);
|
|
|
return () => {
|
|
|
api.previewer.unbind('ready', handleReady);
|
|
|
if (previewBound) {
|
|
|
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_React_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?.focus();
|
|
|
}
|
|
|
}
|
|
|
}, [focusedWidgetIdRef, selectBlock]);
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: external ["wp","privateApis"]
|
|
|
const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/lock-unlock.js
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
const {
|
|
|
lock,
|
|
|
unlock
|
|
|
} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I know using unstable features means my theme or plugin will inevitably break in the next version of WordPress.', '@wordpress/customize-widgets');
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/sidebar-editor-provider.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Internal dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
const {
|
|
|
ExperimentalBlockEditorProvider
|
|
|
} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
|
|
|
function SidebarEditorProvider({
|
|
|
sidebar,
|
|
|
settings,
|
|
|
children
|
|
|
}) {
|
|
|
const [blocks, onInput, onChange] = useSidebarBlockEditor(sidebar);
|
|
|
useBlocksFocusControl(blocks);
|
|
|
return (0,external_React_namespaceObject.createElement)(ExperimentalBlockEditorProvider, {
|
|
|
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({
|
|
|
sidebar
|
|
|
}) {
|
|
|
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_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-welcome-guide"
|
|
|
}, (0,external_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-welcome-guide__image__wrapper"
|
|
|
}, (0,external_React_namespaceObject.createElement)("picture", null, (0,external_React_namespaceObject.createElement)("source", {
|
|
|
srcSet: "https://s.w.org/images/block-editor/welcome-editor.svg",
|
|
|
media: "(prefers-reduced-motion: reduce)"
|
|
|
}), (0,external_React_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_React_namespaceObject.createElement)("h1", {
|
|
|
className: "customize-widgets-welcome-guide__heading"
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets')), (0,external_React_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_React_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_React_namespaceObject.createElement)("hr", {
|
|
|
className: "customize-widgets-welcome-guide__separator"
|
|
|
}), !isEntirelyBlockWidgets && (0,external_React_namespaceObject.createElement)("p", {
|
|
|
className: "customize-widgets-welcome-guide__more-info"
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Want to stick with the old widgets?'), (0,external_React_namespaceObject.createElement)("br", null), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
|
|
|
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/plugins/classic-widgets/')
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('Get the Classic Widgets plugin.'))), (0,external_React_namespaceObject.createElement)("p", {
|
|
|
className: "customize-widgets-welcome-guide__more-info"
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)('New to the block editor?'), (0,external_React_namespaceObject.createElement)("br", null), (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
|
|
|
href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/wordpress-block-editor/')
|
|
|
}, (0,external_wp_i18n_namespaceObject.__)("Here's a detailed guide."))));
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcuts/index.js
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function KeyboardShortcuts({
|
|
|
undo,
|
|
|
redo,
|
|
|
save
|
|
|
}) {
|
|
|
const {
|
|
|
replaceBlocks
|
|
|
} = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
|
|
|
const {
|
|
|
getBlockName,
|
|
|
getSelectedBlockClientId,
|
|
|
getBlockAttributes
|
|
|
} = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blockEditor_namespaceObject.store);
|
|
|
const handleTextLevelShortcut = (event, level) => {
|
|
|
event.preventDefault();
|
|
|
const destinationBlockName = level === 0 ? 'core/paragraph' : 'core/heading';
|
|
|
const currentClientId = getSelectedBlockClientId();
|
|
|
if (currentClientId === null) {
|
|
|
return;
|
|
|
}
|
|
|
const blockName = getBlockName(currentClientId);
|
|
|
if (blockName !== 'core/paragraph' && blockName !== 'core/heading') {
|
|
|
return;
|
|
|
}
|
|
|
const attributes = getBlockAttributes(currentClientId);
|
|
|
const textAlign = blockName === 'core/paragraph' ? 'align' : 'textAlign';
|
|
|
const destinationTextAlign = destinationBlockName === 'core/paragraph' ? 'align' : 'textAlign';
|
|
|
replaceBlocks(currentClientId, (0,external_wp_blocks_namespaceObject.createBlock)(destinationBlockName, {
|
|
|
level,
|
|
|
content: attributes.content,
|
|
|
...{
|
|
|
[destinationTextAlign]: attributes[textAlign]
|
|
|
}
|
|
|
}));
|
|
|
};
|
|
|
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/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();
|
|
|
});
|
|
|
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/transform-heading-to-paragraph', event => handleTextLevelShortcut(event, 0));
|
|
|
[1, 2, 3, 4, 5, 6].forEach(level => {
|
|
|
//the loop is based off on a constant therefore
|
|
|
//the hook will execute the same way every time
|
|
|
//eslint-disable-next-line react-hooks/rules-of-hooks
|
|
|
(0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(`core/customize-widgets/transform-paragraph-to-heading-${level}`, event => handleTextLevelShortcut(event, level));
|
|
|
});
|
|
|
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'
|
|
|
},
|
|
|
// Disable on Apple OS because it conflicts with the browser's
|
|
|
// history shortcut. It's a fine alias for both Windows and Linux.
|
|
|
// Since there's no conflict for Ctrl+Shift+Z on both Windows and
|
|
|
// Linux, we keep it as the default for consistency.
|
|
|
aliases: (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? [] : [{
|
|
|
modifier: 'primary',
|
|
|
character: 'y'
|
|
|
}]
|
|
|
});
|
|
|
registerShortcut({
|
|
|
name: 'core/customize-widgets/save',
|
|
|
category: 'global',
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Save your changes.'),
|
|
|
keyCombination: {
|
|
|
modifier: 'primary',
|
|
|
character: 's'
|
|
|
}
|
|
|
});
|
|
|
registerShortcut({
|
|
|
name: 'core/customize-widgets/transform-heading-to-paragraph',
|
|
|
category: 'block-library',
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Transform heading to paragraph.'),
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: `0`
|
|
|
}
|
|
|
});
|
|
|
[1, 2, 3, 4, 5, 6].forEach(level => {
|
|
|
registerShortcut({
|
|
|
name: `core/customize-widgets/transform-paragraph-to-heading-${level}`,
|
|
|
category: 'block-library',
|
|
|
description: (0,external_wp_i18n_namespaceObject.__)('Transform paragraph to heading.'),
|
|
|
keyCombination: {
|
|
|
modifier: 'access',
|
|
|
character: `${level}`
|
|
|
}
|
|
|
});
|
|
|
});
|
|
|
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 */ const 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_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.ButtonBlockAppender, {
|
|
|
...props,
|
|
|
ref: ref
|
|
|
});
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/index.js
|
|
|
|
|
|
/**
|
|
|
* WordPress dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Internal dependencies
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const {
|
|
|
ExperimentalBlockCanvas: BlockCanvas
|
|
|
} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
|
|
|
function SidebarBlockEditor({
|
|
|
blockEditorSettings,
|
|
|
sidebar,
|
|
|
inserter,
|
|
|
inspector
|
|
|
}) {
|
|
|
const [isInserterOpened, setIsInserterOpened] = useInserter(inserter);
|
|
|
const isMediumViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('small');
|
|
|
const {
|
|
|
hasUploadPermissions,
|
|
|
isFixedToolbarActive,
|
|
|
keepCaretInsideBlock,
|
|
|
isWelcomeGuideActive
|
|
|
} = (0,external_wp_data_namespaceObject.useSelect)(select => {
|
|
|
var _select$canUser;
|
|
|
const {
|
|
|
get
|
|
|
} = select(external_wp_preferences_namespaceObject.store);
|
|
|
return {
|
|
|
hasUploadPermissions: (_select$canUser = select(external_wp_coreData_namespaceObject.store).canUser('create', 'media')) !== null && _select$canUser !== void 0 ? _select$canUser : 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 = ({
|
|
|
onError,
|
|
|
...argumentsObject
|
|
|
}) => {
|
|
|
(0,external_wp_mediaUtils_namespaceObject.uploadMedia)({
|
|
|
wpAllowedMimeTypes: blockEditorSettings.allowedMimeTypes,
|
|
|
onError: ({
|
|
|
message
|
|
|
}) => onError(message),
|
|
|
...argumentsObject
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
return {
|
|
|
...blockEditorSettings,
|
|
|
__experimentalSetIsInserterOpened: setIsInserterOpened,
|
|
|
mediaUpload: mediaUploadBlockEditor,
|
|
|
hasFixedToolbar: isFixedToolbarActive || !isMediumViewport,
|
|
|
keepCaretInsideBlock,
|
|
|
__unstableHasCustomAppender: true
|
|
|
};
|
|
|
}, [hasUploadPermissions, blockEditorSettings, isFixedToolbarActive, isMediumViewport, keepCaretInsideBlock, setIsInserterOpened]);
|
|
|
if (isWelcomeGuideActive) {
|
|
|
return (0,external_React_namespaceObject.createElement)(WelcomeGuide, {
|
|
|
sidebar: sidebar
|
|
|
});
|
|
|
}
|
|
|
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(keyboard_shortcuts.Register, null), (0,external_React_namespaceObject.createElement)(SidebarEditorProvider, {
|
|
|
sidebar: sidebar,
|
|
|
settings: settings
|
|
|
}, (0,external_React_namespaceObject.createElement)(keyboard_shortcuts, {
|
|
|
undo: sidebar.undo,
|
|
|
redo: sidebar.redo,
|
|
|
save: sidebar.save
|
|
|
}), (0,external_React_namespaceObject.createElement)(header, {
|
|
|
sidebar: sidebar,
|
|
|
inserter: inserter,
|
|
|
isInserterOpened: isInserterOpened,
|
|
|
setIsInserterOpened: setIsInserterOpened,
|
|
|
isFixedToolbarActive: isFixedToolbarActive || !isMediumViewport
|
|
|
}), (isFixedToolbarActive || !isMediumViewport) && (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockToolbar, {
|
|
|
hideDragHandle: true
|
|
|
}), (0,external_React_namespaceObject.createElement)(BlockCanvas, {
|
|
|
shouldIframe: false,
|
|
|
styles: settings.defaultEditorStyles,
|
|
|
height: "100%"
|
|
|
}, (0,external_React_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_React_namespaceObject.createElement)("form", {
|
|
|
onSubmit: event => event.preventDefault()
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockInspector, null)), inspector.contentContainer[0])), (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableBlockSettingsMenuFirstItem, null, ({
|
|
|
onClose
|
|
|
}) => (0,external_React_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({
|
|
|
sidebarControls,
|
|
|
activeSidebarControl,
|
|
|
children
|
|
|
}) {
|
|
|
const context = (0,external_wp_element_namespaceObject.useMemo)(() => ({
|
|
|
sidebarControls,
|
|
|
activeSidebarControl
|
|
|
}), [sidebarControls, activeSidebarControl]);
|
|
|
return (0,external_React_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({
|
|
|
api,
|
|
|
sidebarControls,
|
|
|
blockEditorSettings
|
|
|
}) {
|
|
|
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_React_namespaceObject.createElement)(ErrorBoundary, null, (0,external_React_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_React_namespaceObject.createElement)("div", {
|
|
|
className: "customize-widgets-popover",
|
|
|
ref: popoverRef
|
|
|
}, (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.Popover.Slot, null)), parentContainer);
|
|
|
return (0,external_React_namespaceObject.createElement)(external_wp_components_namespaceObject.SlotFillProvider, null, (0,external_React_namespaceObject.createElement)(SidebarControls, {
|
|
|
sidebarControls: sidebarControls,
|
|
|
activeSidebarControl: activeSidebarControl
|
|
|
}, (0,external_React_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({
|
|
|
returnFocusWhenClose
|
|
|
} = {}) {
|
|
|
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() {
|
|
|
controls.forEach(control => {
|
|
|
control.onChangeSectionExpanded?.(expanded, args);
|
|
|
});
|
|
|
_args.completeCallback?.();
|
|
|
}
|
|
|
};
|
|
|
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(...args) {
|
|
|
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(...args) {
|
|
|
for (const callback of this.subscribers) {
|
|
|
callback(...args);
|
|
|
}
|
|
|
}
|
|
|
_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"]
|
|
|
const 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(...args) {
|
|
|
super(...args);
|
|
|
|
|
|
// 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(...args) {
|
|
|
super(...args);
|
|
|
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: ./node_modules/@wordpress/customize-widgets/build-module/filters/move-to-sidebar.js
|
|
|
|
|
|
/**
|
|
|
* 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?.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(oldSetting().filter(id => id !== 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_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, (0,external_React_namespaceObject.createElement)(BlockEdit, {
|
|
|
...props
|
|
|
}), hasMultipleSidebars && canInsertBlockInSidebar && (0,external_React_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockControls, null, (0,external_React_namespaceObject.createElement)(external_wp_widgets_namespaceObject.MoveToWidgetArea, {
|
|
|
widgetAreas: sidebarControls.map(sidebarControl => ({
|
|
|
id: sidebarControl.id,
|
|
|
name: sidebarControl.params.label,
|
|
|
description: sidebarControl.params.description
|
|
|
})),
|
|
|
currentWidgetAreaId: 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;
|
|
|
const {
|
|
|
idBase
|
|
|
} = props.attributes;
|
|
|
const isWide = (_wp$customize$Widgets = wide_widget_display_wp.customize.Widgets.data.availableWidgets.find(widget => widget.id_base === idBase)?.is_wide) !== null && _wp$customize$Widgets !== void 0 ? _wp$customize$Widgets : false;
|
|
|
return (0,external_React_namespaceObject.createElement)(BlockEdit, {
|
|
|
...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).reapplyBlockTypeFilters();
|
|
|
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.createRoot)(container).render((0,external_React_namespaceObject.createElement)(CustomizeWidgets, {
|
|
|
api: build_module_wp.customize,
|
|
|
sidebarControls: sidebarControls,
|
|
|
blockEditorSettings: blockEditorSettings
|
|
|
}));
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
})();
|
|
|
|
|
|
(window.wp = window.wp || {}).customizeWidgets = __webpack_exports__;
|
|
|
/******/ })()
|
|
|
; |
