@wordpress/block-editor 15.9.1-next.8fd3f8831.0 → 15.10.1-next.79a2f3cdd.0

package/build-module/components/block-edit/edit.mjs

@@ -0,0 +1,240 @@
+// packages/block-editor/src/components/block-edit/edit.js
+import clsx from "clsx";
+import {
+  getBlockDefaultClassName,
+  getBlockType,
+  hasBlockSupport,
+  store as blocksStore
+} from "@wordpress/blocks";
+import { withFilters } from "@wordpress/components";
+import { useRegistry, useSelect } from "@wordpress/data";
+import { useCallback, useContext, useMemo } from "@wordpress/element";
+import BlockContext from "../block-context/index.mjs";
+import isURLLike from "../link-control/is-url-like.mjs";
+import {
+  hasPatternOverridesDefaultBinding,
+  replacePatternOverridesDefaultBinding
+} from "../../utils/block-bindings.mjs";
+import { unlock } from "../../lock-unlock.mjs";
+import { PrivateBlockContext } from "../block-list/private-block-context.mjs";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_BLOCK_CONTEXT = {};
+var Edit = (props) => {
+  const { name } = props;
+  const blockType = getBlockType(name);
+  if (!blockType) {
+    return null;
+  }
+  const Component = blockType.edit || blockType.save;
+  return /* @__PURE__ */ jsx(Component, { ...props });
+};
+var EditWithFilters = withFilters("editor.BlockEdit")(Edit);
+var EditWithGeneratedProps = (props) => {
+  const { name, clientId, attributes, setAttributes } = props;
+  const registry = useRegistry();
+  const blockType = getBlockType(name);
+  const blockContext = useContext(BlockContext);
+  const registeredSources = useSelect(
+    (select) => unlock(select(blocksStore)).getAllBlockBindingsSources(),
+    []
+  );
+  const { bindableAttributes } = useContext(PrivateBlockContext);
+  const { blockBindings, context, hasPatternOverrides } = useMemo(() => {
+    const computedContext = blockType?.usesContext ? Object.fromEntries(
+      Object.entries(blockContext).filter(
+        ([key]) => blockType.usesContext.includes(key)
+      )
+    ) : DEFAULT_BLOCK_CONTEXT;
+    if (attributes?.metadata?.bindings) {
+      Object.values(attributes?.metadata?.bindings || {}).forEach(
+        (binding) => {
+          registeredSources[binding?.source]?.usesContext?.forEach(
+            (key) => {
+              computedContext[key] = blockContext[key];
+            }
+          );
+        }
+      );
+    }
+    return {
+      blockBindings: replacePatternOverridesDefaultBinding(
+        attributes?.metadata?.bindings,
+        bindableAttributes
+      ),
+      context: computedContext,
+      hasPatternOverrides: hasPatternOverridesDefaultBinding(
+        attributes?.metadata?.bindings
+      )
+    };
+  }, [
+    blockType?.usesContext,
+    blockContext,
+    attributes?.metadata?.bindings,
+    bindableAttributes,
+    registeredSources
+  ]);
+  const computedAttributes = useSelect(
+    (select) => {
+      if (!blockBindings) {
+        return attributes;
+      }
+      const attributesFromSources = {};
+      const blockBindingsBySource = /* @__PURE__ */ new Map();
+      for (const [attributeName, binding] of Object.entries(
+        blockBindings
+      )) {
+        const { source: sourceName, args: sourceArgs } = binding;
+        const source = registeredSources[sourceName];
+        if (!source || !bindableAttributes?.includes(attributeName)) {
+          continue;
+        }
+        blockBindingsBySource.set(source, {
+          ...blockBindingsBySource.get(source),
+          [attributeName]: {
+            args: sourceArgs
+          }
+        });
+      }
+      if (blockBindingsBySource.size) {
+        for (const [source, bindings] of blockBindingsBySource) {
+          let values = {};
+          if (!source.getValues) {
+            Object.keys(bindings).forEach((attr) => {
+              values[attr] = source.label;
+            });
+          } else {
+            values = source.getValues({
+              select,
+              context,
+              clientId,
+              bindings
+            });
+          }
+          for (const [attributeName, value] of Object.entries(
+            values
+          )) {
+            if (attributeName === "url" && (!value || !isURLLike(value))) {
+              attributesFromSources[attributeName] = null;
+            } else {
+              attributesFromSources[attributeName] = value;
+            }
+          }
+        }
+      }
+      return {
+        ...attributes,
+        ...attributesFromSources
+      };
+    },
+    [
+      attributes,
+      bindableAttributes,
+      blockBindings,
+      clientId,
+      context,
+      registeredSources
+    ]
+  );
+  const setBoundAttributes = useCallback(
+    (nextAttributes) => {
+      if (!blockBindings) {
+        setAttributes(nextAttributes);
+        return;
+      }
+      registry.batch(() => {
+        const keptAttributes = { ...nextAttributes };
+        const blockBindingsBySource = /* @__PURE__ */ new Map();
+        for (const [attributeName, newValue] of Object.entries(
+          keptAttributes
+        )) {
+          if (!blockBindings[attributeName] || !bindableAttributes?.includes(attributeName)) {
+            continue;
+          }
+          const binding = blockBindings[attributeName];
+          const source = registeredSources[binding?.source];
+          if (!source?.setValues) {
+            continue;
+          }
+          blockBindingsBySource.set(source, {
+            ...blockBindingsBySource.get(source),
+            [attributeName]: {
+              args: binding.args,
+              newValue
+            }
+          });
+          delete keptAttributes[attributeName];
+        }
+        if (blockBindingsBySource.size) {
+          for (const [
+            source,
+            bindings
+          ] of blockBindingsBySource) {
+            source.setValues({
+              select: registry.select,
+              dispatch: registry.dispatch,
+              context,
+              clientId,
+              bindings
+            });
+          }
+        }
+        const hasParentPattern = !!context["pattern/overrides"];
+        if (
+          // Don't update non-connected attributes if the block is using pattern overrides
+          // and the editing is happening while overriding the pattern (not editing the original).
+          !(hasPatternOverrides && hasParentPattern) && Object.keys(keptAttributes).length
+        ) {
+          if (hasPatternOverrides) {
+            delete keptAttributes.href;
+          }
+          setAttributes(keptAttributes);
+        }
+      });
+    },
+    [
+      bindableAttributes,
+      blockBindings,
+      clientId,
+      context,
+      hasPatternOverrides,
+      setAttributes,
+      registeredSources,
+      registry
+    ]
+  );
+  if (!blockType) {
+    return null;
+  }
+  if (blockType.apiVersion > 1) {
+    return /* @__PURE__ */ jsx(
+      EditWithFilters,
+      {
+        ...props,
+        attributes: computedAttributes,
+        context,
+        setAttributes: setBoundAttributes
+      }
+    );
+  }
+  const generatedClassName = hasBlockSupport(blockType, "className", true) ? getBlockDefaultClassName(name) : null;
+  const className = clsx(
+    generatedClassName,
+    attributes?.className,
+    props.className
+  );
+  return /* @__PURE__ */ jsx(
+    EditWithFilters,
+    {
+      ...props,
+      attributes: computedAttributes,
+      className,
+      context,
+      setAttributes: setBoundAttributes
+    }
+  );
+};
+var edit_default = EditWithGeneratedProps;
+export {
+  edit_default as default
+};
+//# sourceMappingURL=edit.mjs.map

package/build-module/components/block-edit/index.mjs

@@ -0,0 +1,87 @@
+// packages/block-editor/src/components/block-edit/index.js
+import { useMemo, useContext } from "@wordpress/element";
+import { hasBlockSupport } from "@wordpress/blocks";
+import Edit from "./edit.mjs";
+import {
+  BlockEditContextProvider,
+  useBlockEditContext,
+  mayDisplayControlsKey,
+  mayDisplayParentControlsKey,
+  blockEditingModeKey,
+  blockBindingsKey,
+  isPreviewModeKey
+} from "./context.mjs";
+import { MultipleUsageWarning } from "./multiple-usage-warning.mjs";
+import { PrivateBlockContext } from "../block-list/private-block-context.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+function BlockEdit({
+  mayDisplayControls,
+  mayDisplayParentControls,
+  blockEditingMode,
+  isPreviewMode,
+  // The remaining props are passed through the BlockEdit filters and are thus
+  // public API!
+  ...props
+}) {
+  const {
+    name,
+    isSelected,
+    clientId,
+    attributes = {},
+    __unstableLayoutClassNames
+  } = props;
+  const { layout = null, metadata = {} } = attributes;
+  const { bindings } = metadata;
+  const layoutSupport = hasBlockSupport(name, "layout", false) || hasBlockSupport(name, "__experimentalLayout", false);
+  const { originalBlockClientId } = useContext(PrivateBlockContext);
+  return /* @__PURE__ */ jsxs(
+    BlockEditContextProvider,
+    {
+      value: useMemo(
+        () => ({
+          name,
+          isSelected,
+          clientId,
+          layout: layoutSupport ? layout : null,
+          __unstableLayoutClassNames,
+          // We use symbols in favour of an __unstable prefix to avoid
+          // usage outside of the package (this context is exposed).
+          [mayDisplayControlsKey]: mayDisplayControls,
+          [mayDisplayParentControlsKey]: mayDisplayParentControls,
+          [blockEditingModeKey]: blockEditingMode,
+          [blockBindingsKey]: bindings,
+          [isPreviewModeKey]: isPreviewMode
+        }),
+        [
+          name,
+          isSelected,
+          clientId,
+          layoutSupport,
+          layout,
+          __unstableLayoutClassNames,
+          mayDisplayControls,
+          mayDisplayParentControls,
+          blockEditingMode,
+          bindings,
+          isPreviewMode
+        ]
+      ),
+      children: [
+        /* @__PURE__ */ jsx(Edit, { ...props }),
+        originalBlockClientId && /* @__PURE__ */ jsx(
+          MultipleUsageWarning,
+          {
+            originalBlockClientId,
+            name,
+            onReplace: props.onReplace
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  BlockEdit as default,
+  useBlockEditContext
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/block-edit/multiple-usage-warning.mjs

@@ -0,0 +1,54 @@
+// packages/block-editor/src/components/block-edit/multiple-usage-warning.js
+import { getBlockType } from "@wordpress/blocks";
+import { Button } from "@wordpress/components";
+import { useDispatch } from "@wordpress/data";
+import { __ } from "@wordpress/i18n";
+import { store as blockEditorStore } from "../../store/index.mjs";
+import Warning from "../warning/index.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+function MultipleUsageWarning({
+  originalBlockClientId,
+  name,
+  onReplace
+}) {
+  const { selectBlock } = useDispatch(blockEditorStore);
+  const blockType = getBlockType(name);
+  return /* @__PURE__ */ jsxs(
+    Warning,
+    {
+      actions: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            __next40pxDefaultSize: true,
+            variant: "secondary",
+            onClick: () => selectBlock(originalBlockClientId),
+            children: __("Find original")
+          },
+          "find-original"
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            __next40pxDefaultSize: true,
+            variant: "secondary",
+            onClick: () => onReplace([]),
+            children: __("Remove")
+          },
+          "remove"
+        )
+      ],
+      children: [
+        /* @__PURE__ */ jsxs("strong", { children: [
+          blockType?.title,
+          ": "
+        ] }),
+        __("This block can only be used once.")
+      ]
+    }
+  );
+}
+export {
+  MultipleUsageWarning
+};
+//# sourceMappingURL=multiple-usage-warning.mjs.map

package/build-module/components/block-edit-visually-button/index.mjs

@@ -0,0 +1,30 @@
+// packages/block-editor/src/components/block-edit-visually-button/index.js
+import { ToolbarButton, ToolbarGroup } from "@wordpress/components";
+import { __ } from "@wordpress/i18n";
+import { useSelect, useDispatch } from "@wordpress/data";
+import { store as blockEditorStore } from "../../store/index.mjs";
+import { jsx } from "react/jsx-runtime";
+function BlockEditVisuallyButton({ clientIds }) {
+  const clientId = clientIds.length === 1 ? clientIds[0] : void 0;
+  const canEditVisually = useSelect(
+    (select) => !!clientId && select(blockEditorStore).getBlockMode(clientId) === "html",
+    [clientId]
+  );
+  const { toggleBlockMode } = useDispatch(blockEditorStore);
+  if (!canEditVisually) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(ToolbarGroup, { children: /* @__PURE__ */ jsx(
+    ToolbarButton,
+    {
+      onClick: () => {
+        toggleBlockMode(clientId);
+      },
+      children: __("Edit visually")
+    }
+  ) });
+}
+export {
+  BlockEditVisuallyButton as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/block-editing-mode/index.mjs

@@ -0,0 +1,35 @@
+// packages/block-editor/src/components/block-editing-mode/index.js
+import { useSelect, useDispatch } from "@wordpress/data";
+import { useEffect } from "@wordpress/element";
+import { store as blockEditorStore } from "../../store/index.mjs";
+import {
+  useBlockEditContext,
+  blockEditingModeKey
+} from "../block-edit/context.mjs";
+function useBlockEditingMode(mode) {
+  const context = useBlockEditContext();
+  const { clientId = "" } = context;
+  const { setBlockEditingMode, unsetBlockEditingMode } = useDispatch(blockEditorStore);
+  const globalBlockEditingMode = useSelect(
+    (select) => (
+      // Avoid adding the subscription if not needed!
+      clientId ? null : select(blockEditorStore).getBlockEditingMode()
+    ),
+    [clientId]
+  );
+  useEffect(() => {
+    if (mode) {
+      setBlockEditingMode(clientId, mode);
+    }
+    return () => {
+      if (mode) {
+        unsetBlockEditingMode(clientId);
+      }
+    };
+  }, [clientId, mode, setBlockEditingMode, unsetBlockEditingMode]);
+  return clientId ? context[blockEditingModeKey] : globalBlockEditingMode;
+}
+export {
+  useBlockEditingMode
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/block-full-height-alignment-control/index.mjs

@@ -0,0 +1,27 @@
+// packages/block-editor/src/components/block-full-height-alignment-control/index.js
+import { __ } from "@wordpress/i18n";
+import { ToolbarButton } from "@wordpress/components";
+import { fullscreen } from "@wordpress/icons";
+import { jsx } from "react/jsx-runtime";
+function BlockFullHeightAlignmentControl({
+  isActive,
+  label = __("Full height"),
+  onToggle,
+  isDisabled
+}) {
+  return /* @__PURE__ */ jsx(
+    ToolbarButton,
+    {
+      isActive,
+      icon: fullscreen,
+      label,
+      onClick: () => onToggle(!isActive),
+      disabled: isDisabled
+    }
+  );
+}
+var block_full_height_alignment_control_default = BlockFullHeightAlignmentControl;
+export {
+  block_full_height_alignment_control_default as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/block-heading-level-dropdown/heading-level-icon.mjs

@@ -0,0 +1,31 @@
+// packages/block-editor/src/components/block-heading-level-dropdown/heading-level-icon.js
+import {
+  headingLevel1,
+  headingLevel2,
+  headingLevel3,
+  headingLevel4,
+  headingLevel5,
+  headingLevel6,
+  paragraph
+} from "@wordpress/icons";
+import { Icon } from "@wordpress/components";
+import { jsx } from "react/jsx-runtime";
+var LEVEL_TO_PATH = {
+  0: paragraph,
+  1: headingLevel1,
+  2: headingLevel2,
+  3: headingLevel3,
+  4: headingLevel4,
+  5: headingLevel5,
+  6: headingLevel6
+};
+function HeadingLevelIcon({ level }) {
+  if (LEVEL_TO_PATH[level]) {
+    return /* @__PURE__ */ jsx(Icon, { icon: LEVEL_TO_PATH[level] });
+  }
+  return null;
+}
+export {
+  HeadingLevelIcon as default
+};
+//# sourceMappingURL=heading-level-icon.mjs.map

package/build-module/components/block-heading-level-dropdown/index.mjs

@@ -0,0 +1,46 @@
+// packages/block-editor/src/components/block-heading-level-dropdown/index.js
+import { ToolbarDropdownMenu } from "@wordpress/components";
+import { __, sprintf } from "@wordpress/i18n";
+import HeadingLevelIcon from "./heading-level-icon.mjs";
+import { jsx } from "react/jsx-runtime";
+var HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
+var POPOVER_PROPS = {
+  className: "block-library-heading-level-dropdown"
+};
+function HeadingLevelDropdown({
+  options = HEADING_LEVELS,
+  value,
+  onChange
+}) {
+  const validOptions = options.filter(
+    (option) => option === 0 || HEADING_LEVELS.includes(option)
+  ).sort((a, b) => a - b);
+  return /* @__PURE__ */ jsx(
+    ToolbarDropdownMenu,
+    {
+      popoverProps: POPOVER_PROPS,
+      icon: /* @__PURE__ */ jsx(HeadingLevelIcon, { level: value }),
+      label: __("Change level"),
+      controls: validOptions.map((targetLevel) => {
+        const isActive = targetLevel === value;
+        return {
+          icon: /* @__PURE__ */ jsx(HeadingLevelIcon, { level: targetLevel }),
+          title: targetLevel === 0 ? __("Paragraph") : sprintf(
+            // translators: %d: heading level e.g: "1", "2", "3"
+            __("Heading %d"),
+            targetLevel
+          ),
+          isActive,
+          onClick() {
+            onChange(targetLevel);
+          },
+          role: "menuitemradio"
+        };
+      })
+    }
+  );
+}
+export {
+  HeadingLevelDropdown as default
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/components/block-icon/index.mjs

@@ -0,0 +1,33 @@
+// packages/block-editor/src/components/block-icon/index.js
+import clsx from "clsx";
+import { Icon } from "@wordpress/components";
+import { blockDefault } from "@wordpress/icons";
+import { memo } from "@wordpress/element";
+import { jsx } from "react/jsx-runtime";
+function BlockIcon({ icon, showColors = false, className, context }) {
+  if (icon?.src === "block-default") {
+    icon = {
+      src: blockDefault
+    };
+  }
+  const renderedIcon = /* @__PURE__ */ jsx(Icon, { icon: icon && icon.src ? icon.src : icon, context });
+  const style = showColors ? {
+    backgroundColor: icon && icon.background,
+    color: icon && icon.foreground
+  } : {};
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      style,
+      className: clsx("block-editor-block-icon", className, {
+        "has-colors": showColors
+      }),
+      children: renderedIcon
+    }
+  );
+}
+var block_icon_default = memo(BlockIcon);
+export {
+  block_icon_default as default
+};
+//# sourceMappingURL=index.mjs.map