@wordpress/editor 14.37.0 → 14.37.1-next.79a2f3cdd.0

package/build/dataviews/store/private-actions.cjs

@@ -0,0 +1,194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/editor/src/dataviews/store/private-actions.ts
+var private_actions_exports = {};
+__export(private_actions_exports, {
+  registerEntityAction: () => registerEntityAction,
+  registerEntityField: () => registerEntityField,
+  registerPostTypeSchema: () => registerPostTypeSchema,
+  setIsReady: () => setIsReady,
+  unregisterEntityAction: () => unregisterEntityAction,
+  unregisterEntityField: () => unregisterEntityField
+});
+module.exports = __toCommonJS(private_actions_exports);
+var import_core_data = require("@wordpress/core-data");
+var import_hooks = require("@wordpress/hooks");
+var import_fields = require("@wordpress/fields");
+var import_store = require("../../store/index.cjs");
+var import_constants = require("../../store/constants.cjs");
+var import_content_preview = __toESM(require("../fields/content-preview/index.cjs"));
+var import_lock_unlock = require("../../lock-unlock.cjs");
+function hasEditorNotesSupport(supports) {
+  const editor = supports?.editor;
+  if (Array.isArray(editor)) {
+    return !!editor[0]?.notes;
+  }
+  return false;
+}
+function registerEntityAction(kind, name, config) {
+  return {
+    type: "REGISTER_ENTITY_ACTION",
+    kind,
+    name,
+    config
+  };
+}
+function unregisterEntityAction(kind, name, actionId) {
+  return {
+    type: "UNREGISTER_ENTITY_ACTION",
+    kind,
+    name,
+    actionId
+  };
+}
+function registerEntityField(kind, name, config) {
+  return {
+    type: "REGISTER_ENTITY_FIELD",
+    kind,
+    name,
+    config
+  };
+}
+function unregisterEntityField(kind, name, fieldId) {
+  return {
+    type: "UNREGISTER_ENTITY_FIELD",
+    kind,
+    name,
+    fieldId
+  };
+}
+function setIsReady(kind, name) {
+  return {
+    type: "SET_IS_READY",
+    kind,
+    name
+  };
+}
+var registerPostTypeSchema = (postType) => async ({ registry }) => {
+  const isReady = (0, import_lock_unlock.unlock)(registry.select(import_store.store)).isEntityReady(
+    "postType",
+    postType
+  );
+  if (isReady) {
+    return;
+  }
+  (0, import_lock_unlock.unlock)(registry.dispatch(import_store.store)).setIsReady(
+    "postType",
+    postType
+  );
+  const postTypeConfig = await registry.resolveSelect(import_core_data.store).getPostType(postType);
+  const canCreate = await registry.resolveSelect(import_core_data.store).canUser("create", {
+    kind: "postType",
+    name: postType
+  });
+  const currentTheme = await registry.resolveSelect(import_core_data.store).getCurrentTheme();
+  let canDuplicate = !["wp_block", "wp_template_part"].includes(
+    postTypeConfig.slug
+  ) && canCreate && import_fields.duplicatePost;
+  if (!globalThis.IS_GUTENBERG_PLUGIN) {
+    if ("wp_template" !== postTypeConfig.slug) {
+      canDuplicate = void 0;
+    }
+  }
+  if (postTypeConfig.slug === "wp_template" && !window?.__experimentalTemplateActivate) {
+    canDuplicate = void 0;
+  }
+  const actions = [
+    postTypeConfig.viewable ? import_fields.viewPost : void 0,
+    !!postTypeConfig.supports?.revisions ? import_fields.viewPostRevisions : void 0,
+    // @ts-ignore
+    canDuplicate,
+    postTypeConfig.slug === "wp_template_part" && canCreate && currentTheme?.is_block_theme ? import_fields.duplicateTemplatePart : void 0,
+    canCreate && postTypeConfig.slug === "wp_block" ? import_fields.duplicatePattern : void 0,
+    postTypeConfig.supports?.title ? import_fields.renamePost : void 0,
+    postTypeConfig.supports?.["page-attributes"] ? import_fields.reorderPage : void 0,
+    postTypeConfig.slug === "wp_block" ? import_fields.exportPattern : void 0,
+    import_fields.restorePost,
+    import_fields.resetPost,
+    import_fields.deletePost,
+    import_fields.trashPost,
+    import_fields.permanentlyDeletePost
+  ].filter(Boolean);
+  const fields = [
+    postTypeConfig.supports?.thumbnail && currentTheme?.theme_supports?.["post-thumbnails"] && import_fields.featuredImageField,
+    postTypeConfig.supports?.author && import_fields.authorField,
+    import_fields.statusField,
+    !import_constants.DESIGN_POST_TYPES.includes(postTypeConfig.slug) && import_fields.dateField,
+    import_fields.slugField,
+    postTypeConfig.supports?.["page-attributes"] && import_fields.parentField,
+    postTypeConfig.supports?.comments && import_fields.commentStatusField,
+    postTypeConfig.supports?.trackbacks && import_fields.pingStatusField,
+    (postTypeConfig.supports?.comments || postTypeConfig.supports?.trackbacks) && import_fields.discussionField,
+    import_fields.templateField,
+    import_fields.passwordField,
+    postTypeConfig.supports?.editor && postTypeConfig.viewable && import_content_preview.default,
+    hasEditorNotesSupport(postTypeConfig.supports) && import_fields.notesField
+  ].filter(Boolean);
+  if (postTypeConfig.supports?.title) {
+    let _titleField;
+    if (postType === "page") {
+      _titleField = import_fields.pageTitleField;
+    } else if (postType === "wp_template") {
+      _titleField = import_fields.templateTitleField;
+    } else if (postType === "wp_block") {
+      _titleField = import_fields.patternTitleField;
+    } else {
+      _titleField = import_fields.titleField;
+    }
+    fields.push(_titleField);
+  }
+  registry.batch(() => {
+    actions.forEach((action) => {
+      (0, import_lock_unlock.unlock)(registry.dispatch(import_store.store)).registerEntityAction(
+        "postType",
+        postType,
+        action
+      );
+    });
+    fields.forEach((field) => {
+      (0, import_lock_unlock.unlock)(registry.dispatch(import_store.store)).registerEntityField(
+        "postType",
+        postType,
+        field
+      );
+    });
+  });
+  (0, import_hooks.doAction)("core.registerPostTypeSchema", postType);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerEntityAction,
+  registerEntityField,
+  registerPostTypeSchema,
+  setIsReady,
+  unregisterEntityAction,
+  unregisterEntityField
+});
+//# sourceMappingURL=private-actions.cjs.map

package/build/dataviews/store/private-selectors.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/editor/src/dataviews/store/private-selectors.ts
+var private_selectors_exports = {};
+__export(private_selectors_exports, {
+  getEntityActions: () => getEntityActions,
+  getEntityFields: () => getEntityFields,
+  isEntityReady: () => isEntityReady
+});
+module.exports = __toCommonJS(private_selectors_exports);
+var EMPTY_ARRAY = [];
+function getEntityActions(state, kind, name) {
+  return state.actions[kind]?.[name] ?? EMPTY_ARRAY;
+}
+function getEntityFields(state, kind, name) {
+  return state.fields[kind]?.[name] ?? EMPTY_ARRAY;
+}
+function isEntityReady(state, kind, name) {
+  return state.isReady[kind]?.[name];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntityActions,
+  getEntityFields,
+  isEntityReady
+});
+//# sourceMappingURL=private-selectors.cjs.map

package/build/dataviews/store/reducer.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/editor/src/dataviews/store/reducer.ts
+var reducer_exports = {};
+__export(reducer_exports, {
+  default: () => reducer_default
+});
+module.exports = __toCommonJS(reducer_exports);
+var import_data = require("@wordpress/data");
+function isReady(state = {}, action) {
+  switch (action.type) {
+    case "SET_IS_READY":
+      return {
+        ...state,
+        [action.kind]: {
+          ...state[action.kind],
+          [action.name]: true
+        }
+      };
+  }
+  return state;
+}
+function actions(state = {}, action) {
+  switch (action.type) {
+    case "REGISTER_ENTITY_ACTION":
+      return {
+        ...state,
+        [action.kind]: {
+          ...state[action.kind],
+          [action.name]: [
+            ...(state[action.kind]?.[action.name] ?? []).filter(
+              (_action) => _action.id !== action.config.id
+            ),
+            action.config
+          ]
+        }
+      };
+    case "UNREGISTER_ENTITY_ACTION": {
+      return {
+        ...state,
+        [action.kind]: {
+          ...state[action.kind],
+          [action.name]: (state[action.kind]?.[action.name] ?? []).filter((_action) => _action.id !== action.actionId)
+        }
+      };
+    }
+  }
+  return state;
+}
+function fields(state = {}, action) {
+  switch (action.type) {
+    case "REGISTER_ENTITY_FIELD":
+      return {
+        ...state,
+        [action.kind]: {
+          ...state[action.kind],
+          [action.name]: [
+            ...(state[action.kind]?.[action.name] ?? []).filter(
+              (_field) => _field.id !== action.config.id
+            ),
+            action.config
+          ]
+        }
+      };
+    case "UNREGISTER_ENTITY_FIELD":
+      return {
+        ...state,
+        [action.kind]: {
+          ...state[action.kind],
+          [action.name]: (state[action.kind]?.[action.name] ?? []).filter((_field) => _field.id !== action.fieldId)
+        }
+      };
+  }
+  return state;
+}
+var reducer_default = (0, import_data.combineReducers)({
+  actions,
+  fields,
+  isReady
+});
+//# sourceMappingURL=reducer.cjs.map

package/build/hooks/custom-sources-backwards-compatibility.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+// packages/editor/src/hooks/custom-sources-backwards-compatibility.js
+var import_data = require("@wordpress/data");
+var import_core_data = require("@wordpress/core-data");
+var import_element = require("@wordpress/element");
+var import_compose = require("@wordpress/compose");
+var import_hooks = require("@wordpress/hooks");
+var import_store = require("../store/index.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+var createWithMetaAttributeSource = (metaAttributes) => (0, import_compose.createHigherOrderComponent)(
+  (BlockEdit) => ({ attributes, setAttributes, ...props }) => {
+    const postType = (0, import_data.useSelect)(
+      (select) => select(import_store.store).getCurrentPostType(),
+      []
+    );
+    const [meta, setMeta] = (0, import_core_data.useEntityProp)(
+      "postType",
+      postType,
+      "meta"
+    );
+    const mergedAttributes = (0, import_element.useMemo)(
+      () => ({
+        ...attributes,
+        ...Object.fromEntries(
+          Object.entries(metaAttributes).map(
+            ([attributeKey, metaKey]) => [
+              attributeKey,
+              meta[metaKey]
+            ]
+          )
+        )
+      }),
+      [attributes, meta]
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      BlockEdit,
+      {
+        attributes: mergedAttributes,
+        setAttributes: (nextAttributes) => {
+          const nextMeta = Object.fromEntries(
+            Object.entries(nextAttributes ?? {}).filter(
+              // Filter to intersection of keys between the updated
+              // attributes and those with an associated meta key.
+              ([key]) => key in metaAttributes
+            ).map(([attributeKey, value]) => [
+              // Rename the keys to the expected meta key name.
+              metaAttributes[attributeKey],
+              value
+            ])
+          );
+          if (Object.entries(nextMeta).length) {
+            setMeta(nextMeta);
+          }
+          setAttributes(nextAttributes);
+        },
+        ...props
+      }
+    );
+  },
+  "withMetaAttributeSource"
+);
+function shimAttributeSource(settings) {
+  const metaAttributes = Object.fromEntries(
+    Object.entries(settings.attributes ?? {}).filter(([, { source }]) => source === "meta").map(([attributeKey, { meta }]) => [attributeKey, meta])
+  );
+  if (Object.entries(metaAttributes).length) {
+    settings.edit = createWithMetaAttributeSource(metaAttributes)(
+      settings.edit
+    );
+  }
+  return settings;
+}
+(0, import_hooks.addFilter)(
+  "blocks.registerBlockType",
+  "core/editor/custom-sources-backwards-compatibility/shim-attribute-source",
+  shimAttributeSource
+);
+//# sourceMappingURL=custom-sources-backwards-compatibility.cjs.map

package/build/hooks/default-autocompleters.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+// packages/editor/src/hooks/default-autocompleters.js
+var import_hooks = require("@wordpress/hooks");
+var import_components = require("../components/index.cjs");
+function setDefaultCompleters(completers = []) {
+  completers.push({ ...import_components.userAutocompleter });
+  return completers;
+}
+(0, import_hooks.addFilter)(
+  "editor.Autocomplete.completers",
+  "editor/autocompleters/set-default-completers",
+  setDefaultCompleters
+);
+//# sourceMappingURL=default-autocompleters.cjs.map

package/build/hooks/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+// packages/editor/src/hooks/index.js
+var import_custom_sources_backwards_compatibility = require("./custom-sources-backwards-compatibility.cjs");
+var import_default_autocompleters = require("./default-autocompleters.cjs");
+var import_media_upload = require("./media-upload.cjs");
+var import_pattern_overrides = require("./pattern-overrides.cjs");
+var import_navigation_link_view_button = require("./navigation-link-view-button.cjs");
+var import_template_part_navigation_edit_button = require("./template-part-navigation-edit-button.cjs");
+var import_push_changes_to_global_styles = require("./push-changes-to-global-styles/index.cjs");
+//# sourceMappingURL=index.cjs.map

package/build/hooks/media-upload.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// packages/editor/src/hooks/media-upload.js
+var import_element = require("@wordpress/element");
+var import_hooks = require("@wordpress/hooks");
+var import_deprecated = __toESM(require("@wordpress/deprecated"));
+var import_media_utils = require("@wordpress/media-utils");
+var import_lock_unlock = require("../lock-unlock.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+var { MediaUploadModal: MediaUploadModalComponent } = (0, import_lock_unlock.unlock)(
+  import_media_utils.privateApis
+);
+var MediaUploadModalWrapper = class extends import_element.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      isOpen: false
+    };
+    this.openModal = this.openModal.bind(this);
+    this.closeModal = this.closeModal.bind(this);
+  }
+  openModal() {
+    this.setState({ isOpen: true });
+  }
+  closeModal() {
+    this.setState({ isOpen: false });
+    this.props.onClose?.();
+  }
+  render() {
+    const {
+      allowedTypes,
+      multiple,
+      value,
+      onSelect,
+      title,
+      modalClass,
+      render
+    } = this.props;
+    const { isOpen } = this.state;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      render({ open: this.openModal }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        MediaUploadModalComponent,
+        {
+          allowedTypes,
+          multiple,
+          value,
+          onSelect: (media) => {
+            onSelect(media);
+            this.closeModal();
+          },
+          onClose: this.closeModal,
+          title,
+          isOpen,
+          modalClass
+        }
+      )
+    ] });
+  }
+};
+if (window.__experimentalDataViewsMediaModal) {
+  (0, import_hooks.addFilter)(
+    "editor.MediaUpload",
+    "core/editor/components/media-upload",
+    () => {
+      (0, import_deprecated.default)("Extending MediaUpload as a class component", {
+        since: "7.0",
+        version: "7.2",
+        hint: "MediaUpload will become a function component in WordPress 7.2 Please update any custom implementations to use function components instead."
+      });
+      return MediaUploadModalWrapper;
+    }
+  );
+} else {
+  (0, import_hooks.addFilter)(
+    "editor.MediaUpload",
+    "core/editor/components/media-upload",
+    () => {
+      return import_media_utils.MediaUpload;
+    }
+  );
+}
+//# sourceMappingURL=media-upload.cjs.map

package/build/hooks/navigation-link-view-button.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+// packages/editor/src/hooks/navigation-link-view-button.js
+var import_hooks = require("@wordpress/hooks");
+var import_compose = require("@wordpress/compose");
+var import_element = require("@wordpress/element");
+var import_i18n = require("@wordpress/i18n");
+var import_block_editor = require("@wordpress/block-editor");
+var import_components = require("@wordpress/components");
+var import_data = require("@wordpress/data");
+var import_jsx_runtime = require("react/jsx-runtime");
+var SUPPORTED_BLOCKS = ["core/navigation-link", "core/navigation-submenu"];
+function NavigationViewButton({ attributes }) {
+  const { kind, id, type } = attributes;
+  const blockEditingMode = (0, import_block_editor.useBlockEditingMode)();
+  const onNavigateToEntityRecord = (0, import_data.useSelect)(
+    (select) => select(import_block_editor.store).getSettings().onNavigateToEntityRecord,
+    []
+  );
+  const onViewPage = (0, import_element.useCallback)(() => {
+    if (kind === "post-type" && type === "page" && id && onNavigateToEntityRecord) {
+      onNavigateToEntityRecord({
+        postId: id,
+        postType: type
+      });
+    }
+  }, [kind, id, type, onNavigateToEntityRecord]);
+  if (kind !== "post-type" || type !== "page" || !id || !onNavigateToEntityRecord || blockEditingMode !== "contentOnly") {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_block_editor.__unstableBlockToolbarLastItem, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.ToolbarGroup, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_components.ToolbarButton,
+    {
+      name: "view",
+      title: (0, import_i18n.__)("View"),
+      onClick: onViewPage,
+      children: (0, import_i18n.__)("View")
+    }
+  ) }) });
+}
+var withNavigationViewButton = (0, import_compose.createHigherOrderComponent)(
+  (BlockEdit) => (props) => {
+    const isSupportedBlock = SUPPORTED_BLOCKS.includes(props.name);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BlockEdit, { ...props }, "edit"),
+      props.isSelected && isSupportedBlock && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NavigationViewButton, { ...props })
+    ] });
+  },
+  "withNavigationViewButton"
+);
+(0, import_hooks.addFilter)(
+  "editor.BlockEdit",
+  "core/editor/with-navigation-view-button",
+  withNavigationViewButton
+);
+//# sourceMappingURL=navigation-link-view-button.cjs.map

package/build/hooks/pattern-overrides.cjs

@@ -0,0 +1,69 @@
+"use strict";
+
+// packages/editor/src/hooks/pattern-overrides.js
+var import_hooks = require("@wordpress/hooks");
+var import_patterns = require("@wordpress/patterns");
+var import_compose = require("@wordpress/compose");
+var import_block_editor = require("@wordpress/block-editor");
+var import_data = require("@wordpress/data");
+var import_blocks = require("@wordpress/blocks");
+var import_store = require("../store/index.cjs");
+var import_lock_unlock = require("../lock-unlock.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+var {
+  PatternOverridesControls,
+  ResetOverridesControl,
+  PATTERN_TYPES,
+  PATTERN_SYNC_TYPES
+} = (0, import_lock_unlock.unlock)(import_patterns.privateApis);
+var withPatternOverrideControls = (0, import_compose.createHigherOrderComponent)(
+  (BlockEdit) => (props) => {
+    const isSupportedBlock = (0, import_data.useSelect)(
+      (select) => {
+        const { __experimentalBlockBindingsSupportedAttributes } = select(import_block_editor.store).getSettings();
+        return !!__experimentalBlockBindingsSupportedAttributes?.[props.name];
+      },
+      [props.name]
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BlockEdit, { ...props }, "edit"),
+      props.isSelected && isSupportedBlock && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ControlsWithStoreSubscription, { ...props })
+    ] });
+  },
+  "withPatternOverrideControls"
+);
+function ControlsWithStoreSubscription(props) {
+  const blockEditingMode = (0, import_block_editor.useBlockEditingMode)();
+  const { hasPatternOverridesSource, isEditingSyncedPattern } = (0, import_data.useSelect)(
+    (select) => {
+      const { getCurrentPostType, getEditedPostAttribute } = select(import_store.store);
+      return {
+        // For editing link to the site editor if the theme and user permissions support it.
+        hasPatternOverridesSource: !!(0, import_blocks.getBlockBindingsSource)(
+          "core/pattern-overrides"
+        ),
+        isEditingSyncedPattern: getCurrentPostType() === PATTERN_TYPES.user && getEditedPostAttribute("meta")?.wp_pattern_sync_status !== PATTERN_SYNC_TYPES.unsynced && getEditedPostAttribute("wp_pattern_sync_status") !== PATTERN_SYNC_TYPES.unsynced
+      };
+    },
+    []
+  );
+  const bindings = props.attributes.metadata?.bindings;
+  const hasPatternBindings = !!bindings && Object.values(bindings).some(
+    (binding) => binding.source === "core/pattern-overrides"
+  );
+  const shouldShowPatternOverridesControls = isEditingSyncedPattern && blockEditingMode === "default";
+  const shouldShowResetOverridesControl = !isEditingSyncedPattern && !!props.attributes.metadata?.name && blockEditingMode !== "disabled" && hasPatternBindings;
+  if (!hasPatternOverridesSource) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    shouldShowPatternOverridesControls && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PatternOverridesControls, { ...props }),
+    shouldShowResetOverridesControl && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResetOverridesControl, { ...props })
+  ] });
+}
+(0, import_hooks.addFilter)(
+  "editor.BlockEdit",
+  "core/editor/with-pattern-override-controls",
+  withPatternOverrideControls
+);
+//# sourceMappingURL=pattern-overrides.cjs.map