@wordpress/block-library 9.36.2-next.8fd3f8831.0 → 9.37.2-next.79a2f3cdd.0

package/build-module/query/utils.mjs

@@ -0,0 +1,313 @@
+// packages/block-library/src/query/utils.js
+import { useSelect } from "@wordpress/data";
+import { useMemo } from "@wordpress/element";
+import { store as coreStore } from "@wordpress/core-data";
+import { store as blockEditorStore } from "@wordpress/block-editor";
+import { decodeEntities } from "@wordpress/html-entities";
+import { __ } from "@wordpress/i18n";
+import {
+  cloneBlock,
+  getBlockSupport,
+  store as blocksStore
+} from "@wordpress/blocks";
+var getEntitiesInfo = (entities) => {
+  const mapping = entities?.reduce(
+    (accumulator, entity) => {
+      const { mapById, mapByName, names } = accumulator;
+      mapById[entity.id] = entity;
+      mapByName[entity.name] = entity;
+      names.push(entity.name);
+      return accumulator;
+    },
+    { mapById: {}, mapByName: {}, names: [] }
+  );
+  return {
+    entities,
+    ...mapping
+  };
+};
+var getValueFromObjectPath = (object, path) => {
+  const normalizedPath = path.split(".");
+  let value = object;
+  normalizedPath.forEach((fieldName) => {
+    value = value?.[fieldName];
+  });
+  return value;
+};
+var mapToIHasNameAndId = (entities, path) => {
+  return (entities || []).map((entity) => ({
+    ...entity,
+    name: decodeEntities(getValueFromObjectPath(entity, path))
+  }));
+};
+var usePostTypes = () => {
+  const postTypes = useSelect((select) => {
+    const { getPostTypes } = select(coreStore);
+    const excludedPostTypes = ["attachment"];
+    const filteredPostTypes = getPostTypes({ per_page: -1 })?.filter(
+      ({ viewable, slug }) => viewable && !excludedPostTypes.includes(slug)
+    );
+    return filteredPostTypes;
+  }, []);
+  const postTypesTaxonomiesMap = useMemo(() => {
+    if (!postTypes?.length) {
+      return;
+    }
+    return postTypes.reduce((accumulator, type) => {
+      accumulator[type.slug] = type.taxonomies;
+      return accumulator;
+    }, {});
+  }, [postTypes]);
+  const postTypesSelectOptions = useMemo(
+    () => (postTypes || []).map(({ labels, slug }) => ({
+      label: labels.singular_name,
+      value: slug
+    })),
+    [postTypes]
+  );
+  const postTypeFormatSupportMap = useMemo(() => {
+    if (!postTypes?.length) {
+      return {};
+    }
+    return postTypes.reduce((accumulator, type) => {
+      accumulator[type.slug] = type.supports?.["post-formats"] || false;
+      return accumulator;
+    }, {});
+  }, [postTypes]);
+  return {
+    postTypesTaxonomiesMap,
+    postTypesSelectOptions,
+    postTypeFormatSupportMap
+  };
+};
+var useTaxonomies = (postType) => {
+  const taxonomies = useSelect(
+    (select) => {
+      const { getTaxonomies, getPostType } = select(coreStore);
+      if (getPostType(postType)?.taxonomies?.length > 0) {
+        return getTaxonomies({
+          type: postType,
+          per_page: -1
+        });
+      }
+      return [];
+    },
+    [postType]
+  );
+  return useMemo(() => {
+    return taxonomies?.filter(
+      ({ visibility }) => !!visibility?.publicly_queryable
+    );
+  }, [taxonomies]);
+};
+function useIsPostTypeHierarchical(postType) {
+  return useSelect(
+    (select) => {
+      const type = select(coreStore).getPostType(postType);
+      return type?.viewable && type?.hierarchical;
+    },
+    [postType]
+  );
+}
+function useOrderByOptions(postType) {
+  const supportsCustomOrder = useSelect(
+    (select) => {
+      const type = select(coreStore).getPostType(postType);
+      return !!type?.supports?.["page-attributes"];
+    },
+    [postType]
+  );
+  return useMemo(() => {
+    const orderByOptions = [
+      {
+        label: __("Newest to oldest"),
+        value: "date/desc"
+      },
+      {
+        label: __("Oldest to newest"),
+        value: "date/asc"
+      },
+      {
+        /* translators: Label for ordering posts by title in ascending order. */
+        label: __("A \u2192 Z"),
+        value: "title/asc"
+      },
+      {
+        /* translators: Label for ordering posts by title in descending order. */
+        label: __("Z \u2192 A"),
+        value: "title/desc"
+      }
+    ];
+    if (supportsCustomOrder) {
+      orderByOptions.push(
+        {
+          /* translators: Label for ordering posts by ascending menu order. */
+          label: __("Ascending by order"),
+          value: "menu_order/asc"
+        },
+        {
+          /* translators: Label for ordering posts by descending menu order. */
+          label: __("Descending by order"),
+          value: "menu_order/desc"
+        }
+      );
+    }
+    return orderByOptions;
+  }, [supportsCustomOrder]);
+}
+function useAllowedControls(attributes) {
+  return useSelect(
+    (select) => select(blocksStore).getActiveBlockVariation(
+      "core/query",
+      attributes
+    )?.allowedControls,
+    [attributes]
+  );
+}
+function isControlAllowed(allowedControls, key) {
+  if (!allowedControls) {
+    return true;
+  }
+  return allowedControls.includes(key);
+}
+var getTransformedBlocksFromPattern = (blocks, queryBlockAttributes) => {
+  const {
+    query: { postType, inherit },
+    namespace
+  } = queryBlockAttributes;
+  const clonedBlocks = blocks.map((block) => cloneBlock(block));
+  const queryClientIds = [];
+  const blocksQueue = [...clonedBlocks];
+  while (blocksQueue.length > 0) {
+    const block = blocksQueue.shift();
+    if (block.name === "core/query") {
+      block.attributes.query = {
+        ...block.attributes.query,
+        postType,
+        inherit
+      };
+      if (namespace) {
+        block.attributes.namespace = namespace;
+      }
+      queryClientIds.push(block.clientId);
+    }
+    block.innerBlocks?.forEach((innerBlock) => {
+      blocksQueue.push(innerBlock);
+    });
+  }
+  return { newBlocks: clonedBlocks, queryClientIds };
+};
+function useBlockNameForPatterns(clientId, attributes) {
+  return useSelect(
+    (select) => {
+      const activeVariationName = select(
+        blocksStore
+      ).getActiveBlockVariation("core/query", attributes)?.name;
+      if (!activeVariationName) {
+        return "core/query";
+      }
+      const { getBlockRootClientId, getPatternsByBlockTypes } = select(blockEditorStore);
+      const rootClientId = getBlockRootClientId(clientId);
+      const activePatterns = getPatternsByBlockTypes(
+        `core/query/${activeVariationName}`,
+        rootClientId
+      );
+      return activePatterns.length > 0 ? `core/query/${activeVariationName}` : "core/query";
+    },
+    [clientId, attributes]
+  );
+}
+function useScopedBlockVariations(attributes) {
+  const { activeVariationName, blockVariations } = useSelect(
+    (select) => {
+      const { getActiveBlockVariation, getBlockVariations } = select(blocksStore);
+      return {
+        activeVariationName: getActiveBlockVariation(
+          "core/query",
+          attributes
+        )?.name,
+        blockVariations: getBlockVariations("core/query", "block")
+      };
+    },
+    [attributes]
+  );
+  const variations = useMemo(() => {
+    const isNotConnected = (variation) => !variation.attributes?.namespace;
+    if (!activeVariationName) {
+      return blockVariations.filter(isNotConnected);
+    }
+    const connectedVariations = blockVariations.filter(
+      (variation) => variation.attributes?.namespace?.includes(activeVariationName)
+    );
+    if (!!connectedVariations.length) {
+      return connectedVariations;
+    }
+    return blockVariations.filter(isNotConnected);
+  }, [activeVariationName, blockVariations]);
+  return variations;
+}
+var usePatterns = (clientId, name) => {
+  return useSelect(
+    (select) => {
+      const { getBlockRootClientId, getPatternsByBlockTypes } = select(blockEditorStore);
+      const rootClientId = getBlockRootClientId(clientId);
+      return getPatternsByBlockTypes(name, rootClientId);
+    },
+    [name, clientId]
+  );
+};
+var useUnsupportedBlocks = (clientId) => {
+  return useSelect(
+    (select) => {
+      const { getClientIdsOfDescendants, getBlockName } = select(blockEditorStore);
+      return getClientIdsOfDescendants(clientId).some(
+        (descendantClientId) => {
+          const blockName = getBlockName(descendantClientId);
+          const blockSupportsInteractivity = Object.is(
+            getBlockSupport(blockName, "interactivity"),
+            true
+          );
+          const blockSupportsInteractivityClientNavigation = getBlockSupport(
+            blockName,
+            "interactivity.clientNavigation"
+          );
+          return !blockSupportsInteractivity && !blockSupportsInteractivityClientNavigation;
+        }
+      );
+    },
+    [clientId]
+  );
+};
+function getQueryContextFromTemplate(templateSlug) {
+  if (!templateSlug) {
+    return { isSingular: true };
+  }
+  let isSingular = false;
+  let templateType = templateSlug === "wp" ? "custom" : templateSlug;
+  const singularTemplates = ["404", "blank", "single", "page", "custom"];
+  const templateTypeFromSlug = templateSlug.includes("-") ? templateSlug.split("-", 1)[0] : templateSlug;
+  const queryFromTemplateSlug = templateSlug.includes("-") ? templateSlug.split("-").slice(1).join("-") : "";
+  if (queryFromTemplateSlug) {
+    templateType = templateTypeFromSlug;
+  }
+  isSingular = singularTemplates.includes(templateType);
+  return { isSingular, templateType };
+}
+export {
+  getEntitiesInfo,
+  getQueryContextFromTemplate,
+  getTransformedBlocksFromPattern,
+  getValueFromObjectPath,
+  isControlAllowed,
+  mapToIHasNameAndId,
+  useAllowedControls,
+  useBlockNameForPatterns,
+  useIsPostTypeHierarchical,
+  useOrderByOptions,
+  usePatterns,
+  usePostTypes,
+  useScopedBlockVariations,
+  useTaxonomies,
+  useUnsupportedBlocks
+};
+//# sourceMappingURL=utils.mjs.map

package/build-module/query/variations.mjs

@@ -0,0 +1,92 @@
+// packages/block-library/src/query/variations.js
+import { __ } from "@wordpress/i18n";
+import {
+  titleDate,
+  titleExcerpt,
+  titleDateExcerpt,
+  imageDateTitle
+} from "./icons.mjs";
+var postDate = [
+  "core/post-date",
+  {
+    metadata: {
+      bindings: {
+        datetime: {
+          source: "core/post-data",
+          args: { field: "date" }
+        }
+      }
+    }
+  }
+];
+var variations = [
+  {
+    name: "title-date",
+    title: __("Title & Date"),
+    icon: titleDate,
+    attributes: {},
+    innerBlocks: [
+      ["core/post-template", {}, [["core/post-title"], postDate]],
+      ["core/query-pagination"],
+      ["core/query-no-results"]
+    ],
+    scope: ["block"]
+  },
+  {
+    name: "title-excerpt",
+    title: __("Title & Excerpt"),
+    icon: titleExcerpt,
+    attributes: {},
+    innerBlocks: [
+      [
+        "core/post-template",
+        {},
+        [["core/post-title"], ["core/post-excerpt"]]
+      ],
+      ["core/query-pagination"],
+      ["core/query-no-results"]
+    ],
+    scope: ["block"]
+  },
+  {
+    name: "title-date-excerpt",
+    title: __("Title, Date, & Excerpt"),
+    icon: titleDateExcerpt,
+    attributes: {},
+    innerBlocks: [
+      [
+        "core/post-template",
+        {},
+        [["core/post-title"], postDate, ["core/post-excerpt"]]
+      ],
+      ["core/query-pagination"],
+      ["core/query-no-results"]
+    ],
+    scope: ["block"]
+  },
+  {
+    name: "image-date-title",
+    title: __("Image, Date, & Title"),
+    icon: imageDateTitle,
+    attributes: {},
+    innerBlocks: [
+      [
+        "core/post-template",
+        {},
+        [
+          ["core/post-featured-image"],
+          postDate,
+          ["core/post-title"]
+        ]
+      ],
+      ["core/query-pagination"],
+      ["core/query-no-results"]
+    ],
+    scope: ["block"]
+  }
+];
+var variations_default = variations;
+export {
+  variations_default as default
+};
+//# sourceMappingURL=variations.mjs.map

package/build-module/query/view.mjs

@@ -0,0 +1,54 @@
+// packages/block-library/src/query/view.js
+import {
+  store,
+  getContext,
+  getElement,
+  withSyncEvent
+} from "@wordpress/interactivity";
+var isValidLink = (ref) => ref && ref instanceof window.HTMLAnchorElement && ref.href && (!ref.target || ref.target === "_self") && ref.origin === window.location.origin;
+var isValidEvent = (event) => event.button === 0 && // Left clicks only.
+!event.metaKey && // Open in new tab (Mac).
+!event.ctrlKey && // Open in new tab (Windows).
+!event.altKey && // Download.
+!event.shiftKey && !event.defaultPrevented;
+store(
+  "core/query",
+  {
+    actions: {
+      navigate: withSyncEvent(function* (event) {
+        const ctx = getContext();
+        const { ref } = getElement();
+        const queryRef = ref.closest(
+          ".wp-block-query[data-wp-router-region]"
+        );
+        if (isValidLink(ref) && isValidEvent(event)) {
+          event.preventDefault();
+          const { actions } = yield import("@wordpress/interactivity-router");
+          yield actions.navigate(ref.href);
+          ctx.url = ref.href;
+          const firstAnchor = `.wp-block-post-template a[href]`;
+          queryRef.querySelector(firstAnchor)?.focus();
+        }
+      }),
+      *prefetch() {
+        const { ref } = getElement();
+        if (isValidLink(ref)) {
+          const { actions } = yield import("@wordpress/interactivity-router");
+          yield actions.prefetch(ref.href);
+        }
+      }
+    },
+    callbacks: {
+      *prefetch() {
+        const { url } = getContext();
+        const { ref } = getElement();
+        if (url && isValidLink(ref)) {
+          const { actions } = yield import("@wordpress/interactivity-router");
+          yield actions.prefetch(ref.href);
+        }
+      }
+    }
+  },
+  { lock: true }
+);
+//# sourceMappingURL=view.mjs.map

package/build-module/query-no-results/block.json

@@ -9,6 +9,7 @@
 	"textdomain": "default",
 	"usesContext": [ "queryId", "query" ],
 	"supports": {
+		"anchor": true,
 		"align": true,
 		"reusable": false,
 		"html": false,

package/build-module/query-no-results/edit.mjs

@@ -0,0 +1,25 @@
+// packages/block-library/src/query-no-results/edit.js
+import { useBlockProps, useInnerBlocksProps } from "@wordpress/block-editor";
+import { __ } from "@wordpress/i18n";
+import { jsx } from "react/jsx-runtime";
+var TEMPLATE = [
+  [
+    "core/paragraph",
+    {
+      placeholder: __(
+        "Add text or blocks that will display when a query returns no results."
+      )
+    }
+  ]
+];
+function QueryNoResultsEdit() {
+  const blockProps = useBlockProps();
+  const innerBlocksProps = useInnerBlocksProps(blockProps, {
+    template: TEMPLATE
+  });
+  return /* @__PURE__ */ jsx("div", { ...innerBlocksProps });
+}
+export {
+  QueryNoResultsEdit as default
+};
+//# sourceMappingURL=edit.mjs.map

package/build-module/query-no-results/index.mjs

@@ -0,0 +1,31 @@
+// packages/block-library/src/query-no-results/index.js
+import { __ } from "@wordpress/i18n";
+import { loop as icon } from "@wordpress/icons";
+import initBlock from "../utils/init-block.mjs";
+import metadata from "./block.json";
+import edit from "./edit.mjs";
+import save from "./save.mjs";
+var { name } = metadata;
+var settings = {
+  icon,
+  edit,
+  save,
+  example: {
+    innerBlocks: [
+      {
+        name: "core/paragraph",
+        attributes: {
+          content: __("No posts were found.")
+        }
+      }
+    ]
+  }
+};
+var init = () => initBlock({ name, metadata, settings });
+export {
+  init,
+  metadata,
+  name,
+  settings
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/query-no-results/init.mjs

@@ -0,0 +1,7 @@
+// packages/block-library/src/query-no-results/init.js
+import { init } from "./index.mjs";
+var init_default = init();
+export {
+  init_default as default
+};
+//# sourceMappingURL=init.mjs.map

package/build-module/query-no-results/save.mjs

@@ -0,0 +1,10 @@
+// packages/block-library/src/query-no-results/save.js
+import { InnerBlocks } from "@wordpress/block-editor";
+import { jsx } from "react/jsx-runtime";
+function save() {
+  return /* @__PURE__ */ jsx(InnerBlocks.Content, {});
+}
+export {
+  save as default
+};
+//# sourceMappingURL=save.mjs.map

package/build-module/query-pagination/block.json

@@ -28,6 +28,7 @@
 		"showLabel": "showLabel"
 	},
 	"supports": {
+		"anchor": true,
 		"align": true,
 		"reusable": false,
 		"html": false,

package/build-module/query-pagination/deprecated.mjs

@@ -0,0 +1,16 @@
+// packages/block-library/src/query-pagination/deprecated.js
+import { InnerBlocks, useBlockProps } from "@wordpress/block-editor";
+import { jsx } from "react/jsx-runtime";
+var deprecated = [
+  // Version with wrapper `div` element.
+  {
+    save() {
+      return /* @__PURE__ */ jsx("div", { ...useBlockProps.save(), children: /* @__PURE__ */ jsx(InnerBlocks.Content, {}) });
+    }
+  }
+];
+var deprecated_default = deprecated;
+export {
+  deprecated_default as default
+};
+//# sourceMappingURL=deprecated.mjs.map

package/build-module/query-pagination/edit.mjs

@@ -0,0 +1,117 @@
+// packages/block-library/src/query-pagination/edit.js
+import { __ } from "@wordpress/i18n";
+import {
+  InspectorControls,
+  useBlockProps,
+  useInnerBlocksProps,
+  store as blockEditorStore
+} from "@wordpress/block-editor";
+import { useDispatch, useSelect } from "@wordpress/data";
+import {
+  __experimentalToolsPanel as ToolsPanel,
+  __experimentalToolsPanelItem as ToolsPanelItem
+} from "@wordpress/components";
+import { useEffect } from "@wordpress/element";
+import { QueryPaginationArrowControls } from "./query-pagination-arrow-controls.mjs";
+import { QueryPaginationLabelControl } from "./query-pagination-label-control.mjs";
+import { useToolsPanelDropdownMenuProps } from "../utils/hooks.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var TEMPLATE = [
+  ["core/query-pagination-previous"],
+  ["core/query-pagination-numbers"],
+  ["core/query-pagination-next"]
+];
+function QueryPaginationEdit({
+  attributes: { paginationArrow, showLabel },
+  setAttributes,
+  clientId
+}) {
+  const hasNextPreviousBlocks = useSelect(
+    (select) => {
+      const { getBlocks } = select(blockEditorStore);
+      const innerBlocks = getBlocks(clientId);
+      return innerBlocks?.find((innerBlock) => {
+        return [
+          "core/query-pagination-next",
+          "core/query-pagination-previous"
+        ].includes(innerBlock.name);
+      });
+    },
+    [clientId]
+  );
+  const { __unstableMarkNextChangeAsNotPersistent } = useDispatch(blockEditorStore);
+  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
+  const blockProps = useBlockProps();
+  const innerBlocksProps = useInnerBlocksProps(blockProps, {
+    template: TEMPLATE
+  });
+  useEffect(() => {
+    if (paginationArrow === "none" && !showLabel) {
+      __unstableMarkNextChangeAsNotPersistent();
+      setAttributes({ showLabel: true });
+    }
+  }, [
+    paginationArrow,
+    setAttributes,
+    showLabel,
+    __unstableMarkNextChangeAsNotPersistent
+  ]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    hasNextPreviousBlocks && /* @__PURE__ */ jsx(InspectorControls, { children: /* @__PURE__ */ jsxs(
+      ToolsPanel,
+      {
+        label: __("Settings"),
+        resetAll: () => {
+          setAttributes({
+            paginationArrow: "none",
+            showLabel: true
+          });
+        },
+        dropdownMenuProps,
+        children: [
+          /* @__PURE__ */ jsx(
+            ToolsPanelItem,
+            {
+              hasValue: () => paginationArrow !== "none",
+              label: __("Pagination arrow"),
+              onDeselect: () => setAttributes({ paginationArrow: "none" }),
+              isShownByDefault: true,
+              children: /* @__PURE__ */ jsx(
+                QueryPaginationArrowControls,
+                {
+                  value: paginationArrow,
+                  onChange: (value) => {
+                    setAttributes({ paginationArrow: value });
+                  }
+                }
+              )
+            }
+          ),
+          paginationArrow !== "none" && /* @__PURE__ */ jsx(
+            ToolsPanelItem,
+            {
+              hasValue: () => !showLabel,
+              label: __("Show text"),
+              onDeselect: () => setAttributes({ showLabel: true }),
+              isShownByDefault: true,
+              children: /* @__PURE__ */ jsx(
+                QueryPaginationLabelControl,
+                {
+                  value: showLabel,
+                  onChange: (value) => {
+                    setAttributes({ showLabel: value });
+                  }
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx("nav", { ...innerBlocksProps })
+  ] });
+}
+export {
+  QueryPaginationEdit as default
+};
+//# sourceMappingURL=edit.mjs.map