@wordpress/editor 14.37.0 → 14.37.1-next.ba3aee3a2.0

package/build-module/components/visual-editor/use-edit-content-only-section-exit.mjs

@@ -0,0 +1,39 @@
+// packages/editor/src/components/visual-editor/use-edit-content-only-section-exit.js
+import { useSelect, useDispatch } from "@wordpress/data";
+import { useRefEffect } from "@wordpress/compose";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { unlock } from "../../lock-unlock.mjs";
+function useEditContentOnlySectionExit() {
+  const { getEditedContentOnlySection } = unlock(
+    useSelect(blockEditorStore)
+  );
+  const { stopEditingContentOnlySection } = unlock(
+    useDispatch(blockEditorStore)
+  );
+  return useRefEffect(
+    (node) => {
+      function onClick(event) {
+        const editedContentOnlySection = getEditedContentOnlySection();
+        if (!editedContentOnlySection) {
+          return;
+        }
+        const isClickOutside = !event.target.closest(
+          `[data-block="${editedContentOnlySection}"]`
+        );
+        if (isClickOutside && !event.defaultPrevented) {
+          event.preventDefault();
+          stopEditingContentOnlySection();
+        }
+      }
+      node.addEventListener("click", onClick);
+      return () => {
+        node.removeEventListener("click", onClick);
+      };
+    },
+    [getEditedContentOnlySection, stopEditingContentOnlySection]
+  );
+}
+export {
+  useEditContentOnlySectionExit
+};
+//# sourceMappingURL=use-edit-content-only-section-exit.mjs.map

package/build-module/components/visual-editor/use-padding-appender.mjs

@@ -0,0 +1,50 @@
+// packages/editor/src/components/visual-editor/use-padding-appender.js
+import { useRegistry } from "@wordpress/data";
+import { useRefEffect } from "@wordpress/compose";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { isUnmodifiedDefaultBlock } from "@wordpress/blocks";
+var CSS = ':root :where(.editor-styles-wrapper)::after {content: ""; display: block; height: 40vh;}';
+function usePaddingAppender(enabled) {
+  const registry = useRegistry();
+  const effect = useRefEffect(
+    (node) => {
+      function onMouseDown(event) {
+        if (event.target !== node && // Tests for the parent element because in the iframed editor if the click is
+        // below the padding the target will be the parent element (html) and should
+        // still be treated as intent to append.
+        event.target !== node.parentElement) {
+          return;
+        }
+        const lastChild = node.lastElementChild;
+        if (!lastChild) {
+          return;
+        }
+        const lastChildRect = lastChild.getBoundingClientRect();
+        if (event.clientY < lastChildRect.bottom) {
+          return;
+        }
+        event.preventDefault();
+        const blockOrder = registry.select(blockEditorStore).getBlockOrder("");
+        const lastBlockClientId = blockOrder[blockOrder.length - 1];
+        const lastBlock = registry.select(blockEditorStore).getBlock(lastBlockClientId);
+        const { selectBlock, insertDefaultBlock } = registry.dispatch(blockEditorStore);
+        if (lastBlock && isUnmodifiedDefaultBlock(lastBlock)) {
+          selectBlock(lastBlockClientId);
+        } else {
+          insertDefaultBlock();
+        }
+      }
+      const { ownerDocument } = node;
+      ownerDocument.addEventListener("pointerdown", onMouseDown);
+      return () => {
+        ownerDocument.removeEventListener("pointerdown", onMouseDown);
+      };
+    },
+    [registry]
+  );
+  return enabled ? [effect, CSS] : [];
+}
+export {
+  usePaddingAppender
+};
+//# sourceMappingURL=use-padding-appender.mjs.map

package/build-module/components/visual-editor/use-select-nearest-editable-block.mjs

@@ -0,0 +1,75 @@
+// packages/editor/src/components/visual-editor/use-select-nearest-editable-block.js
+import { useRefEffect } from "@wordpress/compose";
+import { useSelect, useDispatch } from "@wordpress/data";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { unlock } from "../../lock-unlock.mjs";
+var DISTANCE_THRESHOLD = 500;
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function distanceFromRect(x, y, rect) {
+  const dx = x - clamp(x, rect.left, rect.right);
+  const dy = y - clamp(y, rect.top, rect.bottom);
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function useSelectNearestEditableBlock({
+  isEnabled = true
+} = {}) {
+  const { getEnabledClientIdsTree, getBlockName, getBlockOrder } = unlock(
+    useSelect(blockEditorStore)
+  );
+  const { selectBlock } = useDispatch(blockEditorStore);
+  return useRefEffect(
+    (element) => {
+      if (!isEnabled) {
+        return;
+      }
+      const selectNearestEditableBlock = (x, y) => {
+        const editableBlockClientIds = getEnabledClientIdsTree().flatMap(({ clientId }) => {
+          const blockName = getBlockName(clientId);
+          if (blockName === "core/template-part") {
+            return [];
+          }
+          if (blockName === "core/post-content") {
+            const innerBlocks = getBlockOrder(clientId);
+            if (innerBlocks.length) {
+              return innerBlocks;
+            }
+          }
+          return [clientId];
+        });
+        let nearestDistance = Infinity, nearestClientId = null;
+        for (const clientId of editableBlockClientIds) {
+          const block = element.querySelector(
+            `[data-block="${clientId}"]`
+          );
+          if (!block) {
+            continue;
+          }
+          const rect = block.getBoundingClientRect();
+          const distance = distanceFromRect(x, y, rect);
+          if (distance < nearestDistance && distance < DISTANCE_THRESHOLD) {
+            nearestDistance = distance;
+            nearestClientId = clientId;
+          }
+        }
+        if (nearestClientId) {
+          selectBlock(nearestClientId);
+        }
+      };
+      const handleClick = (event) => {
+        const shouldSelect = event.target === element || event.target.classList.contains("is-root-container");
+        if (shouldSelect) {
+          selectNearestEditableBlock(event.clientX, event.clientY);
+        }
+      };
+      element.addEventListener("click", handleClick);
+      return () => element.removeEventListener("click", handleClick);
+    },
+    [isEnabled]
+  );
+}
+export {
+  useSelectNearestEditableBlock as default
+};
+//# sourceMappingURL=use-select-nearest-editable-block.mjs.map

package/build-module/components/visual-editor/use-zoom-out-mode-exit.mjs

@@ -0,0 +1,35 @@
+// packages/editor/src/components/visual-editor/use-zoom-out-mode-exit.js
+import { useSelect, useDispatch } from "@wordpress/data";
+import { useRefEffect } from "@wordpress/compose";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { unlock } from "../../lock-unlock.mjs";
+function useZoomOutModeExit() {
+  const { getSettings, isZoomOut } = unlock(useSelect(blockEditorStore));
+  const { resetZoomLevel } = unlock(useDispatch(blockEditorStore));
+  return useRefEffect(
+    (node) => {
+      function onDoubleClick(event) {
+        if (!isZoomOut()) {
+          return;
+        }
+        if (!event.defaultPrevented) {
+          event.preventDefault();
+          const { __experimentalSetIsInserterOpened } = getSettings();
+          if (typeof __experimentalSetIsInserterOpened === "function") {
+            __experimentalSetIsInserterOpened(false);
+          }
+          resetZoomLevel();
+        }
+      }
+      node.addEventListener("dblclick", onDoubleClick);
+      return () => {
+        node.removeEventListener("dblclick", onDoubleClick);
+      };
+    },
+    [getSettings, isZoomOut, resetZoomLevel]
+  );
+}
+export {
+  useZoomOutModeExit
+};
+//# sourceMappingURL=use-zoom-out-mode-exit.mjs.map

package/build-module/components/word-count/index.mjs

@@ -0,0 +1,18 @@
+// packages/editor/src/components/word-count/index.js
+import { useSelect } from "@wordpress/data";
+import { _x } from "@wordpress/i18n";
+import { count as wordCount } from "@wordpress/wordcount";
+import { store as editorStore } from "../../store/index.mjs";
+import { jsx } from "react/jsx-runtime";
+function WordCount() {
+  const content = useSelect(
+    (select) => select(editorStore).getEditedPostAttribute("content"),
+    []
+  );
+  const wordCountType = _x("words", "Word count type. Do not translate!");
+  return /* @__PURE__ */ jsx("span", { className: "word-count", children: wordCount(content, wordCountType) });
+}
+export {
+  WordCount as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/zoom-out-toggle/index.mjs

@@ -0,0 +1,91 @@
+// packages/editor/src/components/zoom-out-toggle/index.js
+import { Button } from "@wordpress/components";
+import { __ } from "@wordpress/i18n";
+import { useEffect } from "@wordpress/element";
+import { useDispatch, useSelect } from "@wordpress/data";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { square as zoomOutIcon } from "@wordpress/icons";
+import { store as preferencesStore } from "@wordpress/preferences";
+import {
+  useShortcut,
+  store as keyboardShortcutsStore
+} from "@wordpress/keyboard-shortcuts";
+import { isAppleOS } from "@wordpress/keycodes";
+import { unlock } from "../../lock-unlock.mjs";
+import { jsx } from "react/jsx-runtime";
+var ZoomOutToggle = ({ disabled }) => {
+  const { isZoomOut, showIconLabels, isDistractionFree } = useSelect(
+    (select) => ({
+      isZoomOut: unlock(select(blockEditorStore)).isZoomOut(),
+      showIconLabels: select(preferencesStore).get(
+        "core",
+        "showIconLabels"
+      ),
+      isDistractionFree: select(preferencesStore).get(
+        "core",
+        "distractionFree"
+      )
+    })
+  );
+  const { resetZoomLevel, setZoomLevel } = unlock(
+    useDispatch(blockEditorStore)
+  );
+  const { registerShortcut, unregisterShortcut } = useDispatch(
+    keyboardShortcutsStore
+  );
+  useEffect(() => {
+    registerShortcut({
+      name: "core/editor/zoom",
+      category: "global",
+      description: __("Enter or exit zoom out."),
+      keyCombination: {
+        // `primaryShift+0` (`ctrl+shift+0`) is the shortcut for switching
+        // to input mode in Windows, so apply a different key combination.
+        modifier: isAppleOS() ? "primaryShift" : "secondary",
+        character: "0"
+      }
+    });
+    return () => {
+      unregisterShortcut("core/editor/zoom");
+    };
+  }, [registerShortcut, unregisterShortcut]);
+  useShortcut(
+    "core/editor/zoom",
+    () => {
+      if (isZoomOut) {
+        resetZoomLevel();
+      } else {
+        setZoomLevel("auto-scaled");
+      }
+    },
+    {
+      isDisabled: isDistractionFree
+    }
+  );
+  const handleZoomOut = () => {
+    if (isZoomOut) {
+      resetZoomLevel();
+    } else {
+      setZoomLevel("auto-scaled");
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      accessibleWhenDisabled: true,
+      disabled,
+      onClick: handleZoomOut,
+      icon: zoomOutIcon,
+      label: __("Zoom Out"),
+      isPressed: isZoomOut,
+      size: "compact",
+      showTooltip: !showIconLabels,
+      className: "editor-zoom-out-toggle"
+    }
+  );
+};
+var zoom_out_toggle_default = ZoomOutToggle;
+export {
+  zoom_out_toggle_default as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/dataviews/api.mjs

@@ -0,0 +1,43 @@
+// packages/editor/src/dataviews/api.js
+import { dispatch } from "@wordpress/data";
+import { unlock } from "../lock-unlock.mjs";
+import { store as editorStore } from "../store/index.mjs";
+function registerEntityAction(kind, name, config) {
+  const { registerEntityAction: _registerEntityAction } = unlock(
+    dispatch(editorStore)
+  );
+  if (globalThis.IS_GUTENBERG_PLUGIN) {
+    _registerEntityAction(kind, name, config);
+  }
+}
+function unregisterEntityAction(kind, name, actionId) {
+  const { unregisterEntityAction: _unregisterEntityAction } = unlock(
+    dispatch(editorStore)
+  );
+  if (globalThis.IS_GUTENBERG_PLUGIN) {
+    _unregisterEntityAction(kind, name, actionId);
+  }
+}
+function registerEntityField(kind, name, config) {
+  const { registerEntityField: _registerEntityField } = unlock(
+    dispatch(editorStore)
+  );
+  if (globalThis.IS_GUTENBERG_PLUGIN) {
+    _registerEntityField(kind, name, config);
+  }
+}
+function unregisterEntityField(kind, name, fieldId) {
+  const { unregisterEntityField: _unregisterEntityField } = unlock(
+    dispatch(editorStore)
+  );
+  if (globalThis.IS_GUTENBERG_PLUGIN) {
+    _unregisterEntityField(kind, name, fieldId);
+  }
+}
+export {
+  registerEntityAction,
+  registerEntityField,
+  unregisterEntityAction,
+  unregisterEntityField
+};
+//# sourceMappingURL=api.mjs.map

package/build-module/dataviews/fields/content-preview/content-preview-view.mjs

@@ -0,0 +1,76 @@
+// packages/editor/src/dataviews/fields/content-preview/content-preview-view.tsx
+import { __ } from "@wordpress/i18n";
+import {
+  BlockPreview
+} from "@wordpress/block-editor";
+import { useSelect } from "@wordpress/data";
+import { useEntityBlockEditor, store as coreStore } from "@wordpress/core-data";
+import { EditorProvider } from "../../../components/provider/index.mjs";
+import { useStyle } from "../../../components/global-styles/index.mjs";
+import { unlock } from "../../../lock-unlock.mjs";
+import { store as editorStore } from "../../../store/index.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+function PostPreviewContainer({
+  template,
+  post
+}) {
+  const [backgroundColor = "white"] = useStyle("color.background");
+  const [postBlocks] = useEntityBlockEditor("postType", post.type, {
+    id: post.id
+  });
+  const [templateBlocks] = useEntityBlockEditor(
+    "postType",
+    template?.type,
+    {
+      id: template?.id
+    }
+  );
+  const blocks = template && templateBlocks ? templateBlocks : postBlocks;
+  const isEmpty = !blocks?.length;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "editor-fields-content-preview",
+      style: {
+        backgroundColor
+      },
+      children: [
+        isEmpty && /* @__PURE__ */ jsx("span", { className: "editor-fields-content-preview__empty", children: __("Empty content") }),
+        !isEmpty && /* @__PURE__ */ jsx(BlockPreview.Async, { children: /* @__PURE__ */ jsx(BlockPreview, { blocks }) })
+      ]
+    }
+  );
+}
+function PostPreviewView({ item }) {
+  const { settings, template } = useSelect(
+    (select) => {
+      const { canUser, getPostType, getTemplateId, getEntityRecord } = unlock(select(coreStore));
+      const canViewTemplate = canUser("read", {
+        kind: "postType",
+        name: "wp_template"
+      });
+      const _settings = select(editorStore).getEditorSettings();
+      const supportsTemplateMode = _settings.supportsTemplateMode;
+      const isViewable = getPostType(item.type)?.viewable ?? false;
+      const templateId = supportsTemplateMode && isViewable && canViewTemplate ? getTemplateId(item.type, item.id) : null;
+      return {
+        settings: _settings,
+        template: templateId ? getEntityRecord("postType", "wp_template", templateId) : void 0
+      };
+    },
+    [item.type, item.id]
+  );
+  return /* @__PURE__ */ jsx(
+    EditorProvider,
+    {
+      post: item,
+      settings,
+      __unstableTemplate: template,
+      children: /* @__PURE__ */ jsx(PostPreviewContainer, { template, post: item })
+    }
+  );
+}
+export {
+  PostPreviewView as default
+};
+//# sourceMappingURL=content-preview-view.mjs.map

package/build-module/dataviews/fields/content-preview/index.mjs

@@ -0,0 +1,15 @@
+// packages/editor/src/dataviews/fields/content-preview/index.tsx
+import { __ } from "@wordpress/i18n";
+import PostPreviewView from "./content-preview-view.mjs";
+var postPreviewField = {
+  type: "media",
+  id: "content-preview",
+  label: __("Content preview"),
+  render: PostPreviewView,
+  enableSorting: false
+};
+var content_preview_default = postPreviewField;
+export {
+  content_preview_default as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/dataviews/store/private-actions.mjs

@@ -0,0 +1,184 @@
+// packages/editor/src/dataviews/store/private-actions.ts
+import { store as coreStore } from "@wordpress/core-data";
+import { doAction } from "@wordpress/hooks";
+import {
+  viewPost,
+  viewPostRevisions,
+  duplicatePost,
+  duplicatePattern,
+  reorderPage,
+  exportPattern,
+  permanentlyDeletePost,
+  restorePost,
+  trashPost,
+  renamePost,
+  resetPost,
+  deletePost,
+  duplicateTemplatePart,
+  featuredImageField,
+  dateField,
+  parentField,
+  passwordField,
+  commentStatusField,
+  pingStatusField,
+  discussionField,
+  slugField,
+  statusField,
+  authorField,
+  titleField,
+  templateField,
+  templateTitleField,
+  pageTitleField,
+  patternTitleField,
+  notesField
+} from "@wordpress/fields";
+import { store as editorStore } from "../../store/index.mjs";
+import { DESIGN_POST_TYPES } from "../../store/constants.mjs";
+import postPreviewField from "../fields/content-preview/index.mjs";
+import { unlock } from "../../lock-unlock.mjs";
+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 = unlock(registry.select(editorStore)).isEntityReady(
+    "postType",
+    postType
+  );
+  if (isReady) {
+    return;
+  }
+  unlock(registry.dispatch(editorStore)).setIsReady(
+    "postType",
+    postType
+  );
+  const postTypeConfig = await registry.resolveSelect(coreStore).getPostType(postType);
+  const canCreate = await registry.resolveSelect(coreStore).canUser("create", {
+    kind: "postType",
+    name: postType
+  });
+  const currentTheme = await registry.resolveSelect(coreStore).getCurrentTheme();
+  let canDuplicate = !["wp_block", "wp_template_part"].includes(
+    postTypeConfig.slug
+  ) && canCreate && 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 ? viewPost : void 0,
+    !!postTypeConfig.supports?.revisions ? viewPostRevisions : void 0,
+    // @ts-ignore
+    canDuplicate,
+    postTypeConfig.slug === "wp_template_part" && canCreate && currentTheme?.is_block_theme ? duplicateTemplatePart : void 0,
+    canCreate && postTypeConfig.slug === "wp_block" ? duplicatePattern : void 0,
+    postTypeConfig.supports?.title ? renamePost : void 0,
+    postTypeConfig.supports?.["page-attributes"] ? reorderPage : void 0,
+    postTypeConfig.slug === "wp_block" ? exportPattern : void 0,
+    restorePost,
+    resetPost,
+    deletePost,
+    trashPost,
+    permanentlyDeletePost
+  ].filter(Boolean);
+  const fields = [
+    postTypeConfig.supports?.thumbnail && currentTheme?.theme_supports?.["post-thumbnails"] && featuredImageField,
+    postTypeConfig.supports?.author && authorField,
+    statusField,
+    !DESIGN_POST_TYPES.includes(postTypeConfig.slug) && dateField,
+    slugField,
+    postTypeConfig.supports?.["page-attributes"] && parentField,
+    postTypeConfig.supports?.comments && commentStatusField,
+    postTypeConfig.supports?.trackbacks && pingStatusField,
+    (postTypeConfig.supports?.comments || postTypeConfig.supports?.trackbacks) && discussionField,
+    templateField,
+    passwordField,
+    postTypeConfig.supports?.editor && postTypeConfig.viewable && postPreviewField,
+    hasEditorNotesSupport(postTypeConfig.supports) && notesField
+  ].filter(Boolean);
+  if (postTypeConfig.supports?.title) {
+    let _titleField;
+    if (postType === "page") {
+      _titleField = pageTitleField;
+    } else if (postType === "wp_template") {
+      _titleField = templateTitleField;
+    } else if (postType === "wp_block") {
+      _titleField = patternTitleField;
+    } else {
+      _titleField = titleField;
+    }
+    fields.push(_titleField);
+  }
+  registry.batch(() => {
+    actions.forEach((action) => {
+      unlock(registry.dispatch(editorStore)).registerEntityAction(
+        "postType",
+        postType,
+        action
+      );
+    });
+    fields.forEach((field) => {
+      unlock(registry.dispatch(editorStore)).registerEntityField(
+        "postType",
+        postType,
+        field
+      );
+    });
+  });
+  doAction("core.registerPostTypeSchema", postType);
+};
+export {
+  registerEntityAction,
+  registerEntityField,
+  registerPostTypeSchema,
+  setIsReady,
+  unregisterEntityAction,
+  unregisterEntityField
+};
+//# sourceMappingURL=private-actions.mjs.map

package/build-module/dataviews/store/private-selectors.mjs

@@ -0,0 +1,17 @@
+// packages/editor/src/dataviews/store/private-selectors.ts
+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];
+}
+export {
+  getEntityActions,
+  getEntityFields,
+  isEntityReady
+};
+//# sourceMappingURL=private-selectors.mjs.map