@wordpress/editor 14.36.1-next.8fd3f8831.0 → 14.37.0

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+## 14.37.0 (2025-12-23)
+
 ## 14.36.0 (2025-11-26)
 
 ### Internal

package/build/bindings/api.js

@@ -0,0 +1,51 @@
+"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/bindings/api.js
+var api_exports = {};
+__export(api_exports, {
+  registerCoreBlockBindingsSources: () => registerCoreBlockBindingsSources
+});
+module.exports = __toCommonJS(api_exports);
+var import_blocks = require("@wordpress/blocks");
+var import_pattern_overrides = __toESM(require("./pattern-overrides"));
+var import_post_data = __toESM(require("./post-data"));
+var import_post_meta = __toESM(require("./post-meta"));
+var import_term_data = __toESM(require("./term-data"));
+function registerCoreBlockBindingsSources() {
+  (0, import_blocks.registerBlockBindingsSource)(import_pattern_overrides.default);
+  (0, import_blocks.registerBlockBindingsSource)(import_post_data.default);
+  (0, import_blocks.registerBlockBindingsSource)(import_post_meta.default);
+  (0, import_blocks.registerBlockBindingsSource)(import_term_data.default);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerCoreBlockBindingsSources
+});
+//# sourceMappingURL=api.js.map

package/build/bindings/pattern-overrides.js

@@ -0,0 +1,99 @@
+"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/bindings/pattern-overrides.js
+var pattern_overrides_exports = {};
+__export(pattern_overrides_exports, {
+  default: () => pattern_overrides_default
+});
+module.exports = __toCommonJS(pattern_overrides_exports);
+var import_block_editor = require("@wordpress/block-editor");
+var CONTENT = "content";
+var pattern_overrides_default = {
+  name: "core/pattern-overrides",
+  getValues({ select, clientId, context, bindings }) {
+    const patternOverridesContent = context["pattern/overrides"];
+    const { getBlockAttributes } = select(import_block_editor.store);
+    const currentBlockAttributes = getBlockAttributes(clientId);
+    const overridesValues = {};
+    for (const attributeName of Object.keys(bindings)) {
+      const overridableValue = patternOverridesContent?.[currentBlockAttributes?.metadata?.name]?.[attributeName];
+      if (overridableValue === void 0) {
+        overridesValues[attributeName] = currentBlockAttributes[attributeName];
+        continue;
+      } else {
+        overridesValues[attributeName] = overridableValue === "" ? void 0 : overridableValue;
+      }
+    }
+    return overridesValues;
+  },
+  setValues({ select, dispatch, clientId, bindings }) {
+    const { getBlockAttributes, getBlockParentsByBlockName, getBlocks } = select(import_block_editor.store);
+    const currentBlockAttributes = getBlockAttributes(clientId);
+    const blockName = currentBlockAttributes?.metadata?.name;
+    if (!blockName) {
+      return;
+    }
+    const [patternClientId] = getBlockParentsByBlockName(
+      clientId,
+      "core/block",
+      true
+    );
+    const attributes = Object.entries(bindings).reduce(
+      (attrs, [key, { newValue }]) => {
+        attrs[key] = newValue;
+        return attrs;
+      },
+      {}
+    );
+    if (!patternClientId) {
+      const syncBlocksWithSameName = (blocks) => {
+        for (const block of blocks) {
+          if (block.attributes?.metadata?.name === blockName) {
+            dispatch(import_block_editor.store).updateBlockAttributes(
+              block.clientId,
+              attributes
+            );
+          }
+          syncBlocksWithSameName(block.innerBlocks);
+        }
+      };
+      syncBlocksWithSameName(getBlocks());
+      return;
+    }
+    const currentBindingValue = getBlockAttributes(patternClientId)?.[CONTENT];
+    dispatch(import_block_editor.store).updateBlockAttributes(patternClientId, {
+      [CONTENT]: {
+        ...currentBindingValue,
+        [blockName]: {
+          ...currentBindingValue?.[blockName],
+          ...Object.entries(attributes).reduce(
+            (acc, [key, value]) => {
+              acc[key] = value === void 0 ? "" : value;
+              return acc;
+            },
+            {}
+          )
+        }
+      }
+    });
+  },
+  canUserEditValue: () => true
+};
+//# sourceMappingURL=pattern-overrides.js.map

package/build/bindings/post-data.js

@@ -0,0 +1,137 @@
+"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/bindings/post-data.js
+var post_data_exports = {};
+__export(post_data_exports, {
+  default: () => post_data_default
+});
+module.exports = __toCommonJS(post_data_exports);
+var import_i18n = require("@wordpress/i18n");
+var import_core_data = require("@wordpress/core-data");
+var import_block_editor = require("@wordpress/block-editor");
+var NAVIGATION_BLOCK_TYPES = [
+  "core/navigation-link",
+  "core/navigation-submenu"
+];
+var postDataFields = [
+  {
+    label: (0, import_i18n.__)("Post Date"),
+    args: { field: "date" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Post Modified Date"),
+    args: { field: "modified" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Post Link"),
+    args: { field: "link" },
+    type: "string"
+  }
+];
+var post_data_default = {
+  name: "core/post-data",
+  getValues({ select, context, bindings, clientId }) {
+    const { getBlockAttributes, getBlockName } = select(import_block_editor.store);
+    const blockName = getBlockName(clientId);
+    const isNavigationBlock = NAVIGATION_BLOCK_TYPES.includes(blockName);
+    let postId, postType;
+    if (isNavigationBlock) {
+      const blockAttributes = getBlockAttributes(clientId);
+      postId = blockAttributes?.id;
+      postType = blockAttributes?.type;
+    } else {
+      postId = context?.postId;
+      postType = context?.postType;
+    }
+    const { getEditedEntityRecord } = select(import_core_data.store);
+    const entityDataValues = getEditedEntityRecord(
+      "postType",
+      postType,
+      postId
+    );
+    const newValues = {};
+    for (const [attributeName, binding] of Object.entries(bindings)) {
+      const postDataField = postDataFields.find(
+        (field) => field.args.field === binding.args.field
+      );
+      if (!postDataField) {
+        newValues[attributeName] = binding.args.field;
+      } else if (!entityDataValues) {
+        newValues[attributeName] = postDataField.label;
+      } else {
+        newValues[attributeName] = entityDataValues[binding.args.field];
+      }
+    }
+    return newValues;
+  },
+  setValues({ dispatch, context, bindings, clientId, select }) {
+    const { getBlockName } = select(import_block_editor.store);
+    const blockName = getBlockName(clientId);
+    if (NAVIGATION_BLOCK_TYPES.includes(blockName)) {
+      return false;
+    }
+    const newData = {};
+    Object.values(bindings).forEach(({ args, newValue }) => {
+      newData[args.field] = newValue;
+    });
+    dispatch(import_core_data.store).editEntityRecord(
+      "postType",
+      context?.postType,
+      context?.postId,
+      newData
+    );
+  },
+  canUserEditValue({ select, context }) {
+    const { getBlockName, getSelectedBlockClientId } = select(import_block_editor.store);
+    const clientId = getSelectedBlockClientId();
+    const blockName = getBlockName(clientId);
+    if (NAVIGATION_BLOCK_TYPES.includes(blockName)) {
+      return false;
+    }
+    if (context?.query || context?.queryId) {
+      return false;
+    }
+    if (!context?.postType) {
+      return false;
+    }
+    const canUserEdit = select(import_core_data.store).canUser("update", {
+      kind: "postType",
+      name: context?.postType,
+      id: context?.postId
+    });
+    if (!canUserEdit) {
+      return false;
+    }
+    return true;
+  },
+  getFieldsList({ context, select }) {
+    const selectedBlock = select(import_block_editor.store).getSelectedBlock();
+    if (selectedBlock?.name !== "core/post-date") {
+      return [];
+    }
+    if (!context || !context.postId || !context.postType) {
+      return [];
+    }
+    return postDataFields;
+  }
+};
+//# sourceMappingURL=post-data.js.map

package/build/bindings/post-meta.js

@@ -0,0 +1,129 @@
+"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/bindings/post-meta.js
+var post_meta_exports = {};
+__export(post_meta_exports, {
+  default: () => post_meta_default
+});
+module.exports = __toCommonJS(post_meta_exports);
+var import_core_data = require("@wordpress/core-data");
+var import_store = require("../store");
+var import_lock_unlock = require("../lock-unlock");
+function getPostMetaFields(select, context) {
+  const { getRegisteredPostMeta } = (0, import_lock_unlock.unlock)(select(import_core_data.store));
+  const registeredFields = getRegisteredPostMeta(context?.postType);
+  const metaFields = [];
+  Object.entries(registeredFields).forEach(([key, props]) => {
+    if (key === "footnotes" || key.charAt(0) === "_") {
+      return;
+    }
+    metaFields.push({
+      label: props.title || key,
+      args: { key },
+      default: props.default,
+      type: props.type
+    });
+  });
+  return metaFields;
+}
+function getValue({ select, context, args }) {
+  const metaFields = getPostMetaFields(select, context);
+  const metaField = metaFields.find(
+    (field) => field.args.key === args.key
+  );
+  if (!metaField) {
+    return args.key;
+  }
+  if (!context?.postId) {
+    return metaField.default || metaField.label || args.key;
+  }
+  const { getEditedEntityRecord } = select(import_core_data.store);
+  const entityMetaValues = getEditedEntityRecord(
+    "postType",
+    context?.postType,
+    context?.postId
+  ).meta;
+  return entityMetaValues?.[args.key] ?? metaField?.label ?? args.key;
+}
+var post_meta_default = {
+  name: "core/post-meta",
+  getValues({ select, context, bindings }) {
+    const newValues = {};
+    for (const [attributeName, binding] of Object.entries(bindings)) {
+      newValues[attributeName] = getValue({
+        select,
+        context,
+        args: binding.args
+      });
+    }
+    return newValues;
+  },
+  setValues({ dispatch, context, bindings }) {
+    const newMeta = {};
+    Object.values(bindings).forEach(({ args, newValue }) => {
+      newMeta[args.key] = newValue;
+    });
+    dispatch(import_core_data.store).editEntityRecord(
+      "postType",
+      context?.postType,
+      context?.postId,
+      {
+        meta: newMeta
+      }
+    );
+  },
+  canUserEditValue({ select, context, args }) {
+    if (context?.query || context?.queryId) {
+      return false;
+    }
+    if (!context?.postType) {
+      return false;
+    }
+    const metaFields = getPostMetaFields(select, context);
+    const hasMatchingMetaField = metaFields.some(
+      (field) => field.args.key === args.key
+    );
+    if (!hasMatchingMetaField) {
+      return false;
+    }
+    const areCustomFieldsEnabled = select(import_store.store).getEditorSettings().enableCustomFields;
+    if (areCustomFieldsEnabled) {
+      return false;
+    }
+    const canUserEdit = select(import_core_data.store).canUser("update", {
+      kind: "postType",
+      name: context?.postType,
+      id: context?.postId
+    });
+    if (!canUserEdit) {
+      return false;
+    }
+    return true;
+  },
+  getFieldsList({ select, context }) {
+    const metaFields = getPostMetaFields(select, context);
+    return metaFields.map(
+      ({ default: defaultProp, ...otherProps }) => ({
+        ...otherProps
+      })
+    );
+  }
+};
+//# sourceMappingURL=post-meta.js.map

package/build/bindings/term-data.js

@@ -0,0 +1,159 @@
+"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/bindings/term-data.js
+var term_data_exports = {};
+__export(term_data_exports, {
+  default: () => term_data_default,
+  termDataFields: () => termDataFields
+});
+module.exports = __toCommonJS(term_data_exports);
+var import_i18n = require("@wordpress/i18n");
+var import_core_data = require("@wordpress/core-data");
+var import_block_editor = require("@wordpress/block-editor");
+var NAVIGATION_BLOCK_TYPES = [
+  "core/navigation-link",
+  "core/navigation-submenu"
+];
+var termDataFields = [
+  {
+    label: (0, import_i18n.__)("Term ID"),
+    args: { field: "id" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Name"),
+    args: { field: "name" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Slug"),
+    args: { field: "slug" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Link"),
+    args: { field: "link" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Description"),
+    args: { field: "description" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Parent ID"),
+    args: { field: "parent" },
+    type: "string"
+  },
+  {
+    label: (0, import_i18n.__)("Count"),
+    args: { field: "count" },
+    type: "string"
+  }
+];
+var term_data_default = {
+  name: "core/term-data",
+  usesContext: ["taxonomy", "termId", "termData"],
+  getValues({ select, context, bindings, clientId }) {
+    const { getEntityRecord } = select(import_core_data.store);
+    const { getBlockAttributes, getBlockName } = select(import_block_editor.store);
+    const blockName = getBlockName(clientId);
+    const isNavigationBlock = NAVIGATION_BLOCK_TYPES.includes(blockName);
+    let termDataValues;
+    if (isNavigationBlock) {
+      const blockAttributes = getBlockAttributes(clientId);
+      const typeFromAttributes = blockAttributes?.type;
+      const taxonomy = typeFromAttributes === "tag" ? "post_tag" : typeFromAttributes;
+      termDataValues = getEntityRecord(
+        "taxonomy",
+        taxonomy,
+        blockAttributes?.id
+      );
+    } else if (context.termId && context.taxonomy) {
+      termDataValues = getEntityRecord(
+        "taxonomy",
+        context.taxonomy,
+        context.termId
+      );
+    }
+    if (!termDataValues && context?.termData && !isNavigationBlock) {
+      termDataValues = context.termData;
+    }
+    const newValues = {};
+    for (const [attributeName, binding] of Object.entries(bindings)) {
+      const termDataField = termDataFields.find(
+        (field) => field.args.field === binding.args.field
+      );
+      if (!termDataField) {
+        newValues[attributeName] = binding.args.field;
+      } else if (!termDataValues || termDataValues[binding.args.field] === void 0) {
+        newValues[attributeName] = termDataField.label;
+      } else if (binding.args.field === "count") {
+        newValues[attributeName] = "(" + termDataValues[binding.args.field] + ")";
+      } else {
+        newValues[attributeName] = termDataValues[binding.args.field];
+      }
+    }
+    return newValues;
+  },
+  // eslint-disable-next-line no-unused-vars
+  setValues({ dispatch, context, bindings }) {
+    return false;
+  },
+  canUserEditValue({ select, context }) {
+    const { getBlockName, getSelectedBlockClientId } = select(import_block_editor.store);
+    const clientId = getSelectedBlockClientId();
+    const blockName = getBlockName(clientId);
+    if (NAVIGATION_BLOCK_TYPES.includes(blockName)) {
+      return false;
+    }
+    if (context?.termQuery) {
+      return false;
+    }
+    if (!context?.taxonomy || !context?.termId) {
+      return false;
+    }
+    return false;
+  },
+  getFieldsList({ context, select }) {
+    const { getBlockAttributes, getBlockName, getSelectedBlockClientId } = select(import_block_editor.store);
+    const clientId = getSelectedBlockClientId();
+    const blockName = getBlockName(clientId);
+    if (NAVIGATION_BLOCK_TYPES.includes(blockName)) {
+      const blockAttributes = getBlockAttributes(clientId);
+      if (!blockAttributes || !blockAttributes.id || !blockAttributes.type) {
+        return [];
+      }
+      return termDataFields;
+    }
+    if (!context) {
+      return [];
+    }
+    if (context.taxonomy && context.termId || context.termData) {
+      return termDataFields;
+    }
+    return [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  termDataFields
+});
+//# sourceMappingURL=term-data.js.map

package/build/components/autocompleters/index.js

@@ -0,0 +1,41 @@
+"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/components/autocompleters/index.js
+var autocompleters_exports = {};
+__export(autocompleters_exports, {
+  userAutocompleter: () => import_user.default
+});
+module.exports = __toCommonJS(autocompleters_exports);
+var import_user = __toESM(require("./user"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  userAutocompleter
+});
+//# sourceMappingURL=index.js.map