@wordpress/edit-site 6.32.0 → 6.32.1-next.b8c8708f3.0

package/build/components/add-new-template/utils.js

@@ -1,104 +1,86 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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);
+var utils_exports = {};
+__export(utils_exports, {
+  mapToIHasNameAndId: () => mapToIHasNameAndId,
+  useAuthorMenuItem: () => useAuthorMenuItem,
+  useDefaultTemplateTypes: () => useDefaultTemplateTypes,
+  useExistingTemplates: () => useExistingTemplates,
+  usePostTypeArchiveMenuItems: () => usePostTypeArchiveMenuItems,
+  usePostTypeMenuItems: () => usePostTypeMenuItems,
+  useTaxonomiesMenuItems: () => useTaxonomiesMenuItems
 });
-exports.mapToIHasNameAndId = void 0;
-exports.useAuthorMenuItem = useAuthorMenuItem;
-exports.useExistingTemplates = exports.useDefaultTemplateTypes = void 0;
-exports.usePostTypeArchiveMenuItems = usePostTypeArchiveMenuItems;
-exports.useTaxonomiesMenuItems = exports.usePostTypeMenuItems = void 0;
-var _data = require("@wordpress/data");
-var _coreData = require("@wordpress/core-data");
-var _htmlEntities = require("@wordpress/html-entities");
-var _element = require("@wordpress/element");
-var _i18n = require("@wordpress/i18n");
-var _icons = require("@wordpress/icons");
-var _url = require("@wordpress/url");
-var _constants = require("../../utils/constants");
-/**
- * WordPress dependencies
- */
-
-/**
- * Internal dependencies
- */
-
+module.exports = __toCommonJS(utils_exports);
+var import_data = require("@wordpress/data");
+var import_core_data = require("@wordpress/core-data");
+var import_html_entities = require("@wordpress/html-entities");
+var import_element = require("@wordpress/element");
+var import_i18n = require("@wordpress/i18n");
+var import_icons = require("@wordpress/icons");
+var import_url = require("@wordpress/url");
+var import_constants = require("../../utils/constants");
 const EMPTY_OBJECT = {};
-
-/**
- * @typedef IHasNameAndId
- * @property {string|number} id   The entity's id.
- * @property {string}        name The entity's name.
- */
-
 const getValueFromObjectPath = (object, path) => {
   let value = object;
-  path.split('.').forEach(fieldName => {
+  path.split(".").forEach((fieldName) => {
     value = value?.[fieldName];
   });
   return value;
 };
-
-/**
- * Helper that adds a prefix to a post slug. The slug needs to be URL-decoded first,
- * so that we have raw Unicode characters there. The server will truncate the slug to
- * 200 characters, respecing Unicode char boundary. On the other hand, the server
- * doesn't detect urlencoded octet boundary and can possibly construct slugs that
- * are not valid urlencoded strings.
- * @param {string} prefix The prefix to add to the slug.
- * @param {string} slug   The slug to add the prefix to.
- * @return {string} The slug with the prefix.
- */
 function prefixSlug(prefix, slug) {
-  return `${prefix}-${(0, _url.safeDecodeURI)(slug)}`;
+  return `${prefix}-${(0, import_url.safeDecodeURI)(slug)}`;
 }
-
-/**
- * Helper util to map records to add a `name` prop from a
- * provided path, in order to handle all entities in the same
- * fashion(implementing`IHasNameAndId` interface).
- *
- * @param {Object[]} entities The array of entities.
- * @param {string}   path     The path to map a `name` property from the entity.
- * @return {IHasNameAndId[]} An array of entities that now implement the `IHasNameAndId` interface.
- */
 const mapToIHasNameAndId = (entities, path) => {
-  return (entities || []).map(entity => ({
+  return (entities || []).map((entity) => ({
     ...entity,
-    name: (0, _htmlEntities.decodeEntities)(getValueFromObjectPath(entity, path))
+    name: (0, import_html_entities.decodeEntities)(getValueFromObjectPath(entity, path))
   }));
 };
-
-/**
- * @typedef {Object} EntitiesInfo
- * @property {boolean}  hasEntities         If an entity has available records(posts, terms, etc..).
- * @property {number[]} existingEntitiesIds An array of the existing entities ids.
- */
-exports.mapToIHasNameAndId = mapToIHasNameAndId;
 const useExistingTemplates = () => {
-  return (0, _data.useSelect)(select => select(_coreData.store).getEntityRecords('postType', _constants.TEMPLATE_POST_TYPE, {
-    per_page: -1
-  }), []);
+  return (0, import_data.useSelect)(
+    (select) => select(import_core_data.store).getEntityRecords(
+      "postType",
+      import_constants.TEMPLATE_POST_TYPE,
+      {
+        per_page: -1
+      }
+    ),
+    []
+  );
 };
-exports.useExistingTemplates = useExistingTemplates;
 const useDefaultTemplateTypes = () => {
-  return (0, _data.useSelect)(select => select(_coreData.store).getCurrentTheme()?.default_template_types || [], []);
+  return (0, import_data.useSelect)(
+    (select) => select(import_core_data.store).getCurrentTheme()?.default_template_types || [],
+    []
+  );
 };
-exports.useDefaultTemplateTypes = useDefaultTemplateTypes;
 const usePublicPostTypes = () => {
-  const postTypes = (0, _data.useSelect)(select => select(_coreData.store).getPostTypes({
-    per_page: -1
-  }), []);
-  return (0, _element.useMemo)(() => {
-    const excludedPostTypes = ['attachment'];
-    return postTypes?.filter(({
-      viewable,
-      slug
-    }) => viewable && !excludedPostTypes.includes(slug)).sort((a, b) => {
-      // Sort post types alphabetically by name,
-      // but exclude the built-in 'post' type from sorting.
-      if (a.slug === 'post' || b.slug === 'post') {
+  const postTypes = (0, import_data.useSelect)(
+    (select) => select(import_core_data.store).getPostTypes({ per_page: -1 }),
+    []
+  );
+  return (0, import_element.useMemo)(() => {
+    const excludedPostTypes = ["attachment"];
+    return postTypes?.filter(
+      ({ viewable, slug }) => viewable && !excludedPostTypes.includes(slug)
+    ).sort((a, b) => {
+      if (a.slug === "post" || b.slug === "post") {
         return 0;
       }
       return a.name.localeCompare(b.name);
@@ -106,379 +88,405 @@ const usePublicPostTypes = () => {
   }, [postTypes]);
 };
 const usePublicTaxonomies = () => {
-  const taxonomies = (0, _data.useSelect)(select => select(_coreData.store).getTaxonomies({
-    per_page: -1
-  }), []);
-  return (0, _element.useMemo)(() => {
-    return taxonomies?.filter(({
-      visibility
-    }) => visibility?.publicly_queryable);
+  const taxonomies = (0, import_data.useSelect)(
+    (select) => select(import_core_data.store).getTaxonomies({ per_page: -1 }),
+    []
+  );
+  return (0, import_element.useMemo)(() => {
+    return taxonomies?.filter(
+      ({ visibility }) => visibility?.publicly_queryable
+    );
   }, [taxonomies]);
 };
 function usePostTypeArchiveMenuItems() {
   const publicPostTypes = usePublicPostTypes();
-  const postTypesWithArchives = (0, _element.useMemo)(() => publicPostTypes?.filter(postType => postType.has_archive), [publicPostTypes]);
+  const postTypesWithArchives = (0, import_element.useMemo)(
+    () => publicPostTypes?.filter((postType) => postType.has_archive),
+    [publicPostTypes]
+  );
   const existingTemplates = useExistingTemplates();
-  // We need to keep track of naming conflicts. If a conflict
-  // occurs, we need to add slug.
-  const postTypeLabels = (0, _element.useMemo)(() => publicPostTypes?.reduce((accumulator, {
-    labels
-  }) => {
-    const singularName = labels.singular_name.toLowerCase();
-    accumulator[singularName] = (accumulator[singularName] || 0) + 1;
-    return accumulator;
-  }, {}), [publicPostTypes]);
-  const needsUniqueIdentifier = (0, _element.useCallback)(({
-    labels,
-    slug
-  }) => {
-    const singularName = labels.singular_name.toLowerCase();
-    return postTypeLabels[singularName] > 1 && singularName !== slug;
-  }, [postTypeLabels]);
-  return (0, _element.useMemo)(() => postTypesWithArchives?.filter(postType => !(existingTemplates || []).some(existingTemplate => existingTemplate.slug === 'archive-' + postType.slug)).map(postType => {
-    let title;
-    if (needsUniqueIdentifier(postType)) {
-      title = (0, _i18n.sprintf)(
-      // translators: %1s: Name of the post type e.g: "Post"; %2s: Slug of the post type e.g: "book".
-      (0, _i18n.__)('Archive: %1$s (%2$s)'), postType.labels.singular_name, postType.slug);
-    } else {
-      title = (0, _i18n.sprintf)(
-      // translators: %s: Name of the post type e.g: "Post".
-      (0, _i18n.__)('Archive: %s'), postType.labels.singular_name);
-    }
-    return {
-      slug: 'archive-' + postType.slug,
-      description: (0, _i18n.sprintf)(
-      // translators: %s: Name of the post type e.g: "Post".
-      (0, _i18n.__)('Displays an archive with the latest posts of type: %s.'), postType.labels.singular_name),
-      title,
-      // `icon` is the `menu_icon` property of a post type. We
-      // only handle `dashicons` for now, even if the `menu_icon`
-      // also supports urls and svg as values.
-      icon: typeof postType.icon === 'string' && postType.icon.startsWith('dashicons-') ? postType.icon.slice(10) : _icons.archive,
-      templatePrefix: 'archive'
-    };
-  }) || [], [postTypesWithArchives, existingTemplates, needsUniqueIdentifier]);
+  const postTypeLabels = (0, import_element.useMemo)(
+    () => publicPostTypes?.reduce((accumulator, { labels }) => {
+      const singularName = labels.singular_name.toLowerCase();
+      accumulator[singularName] = (accumulator[singularName] || 0) + 1;
+      return accumulator;
+    }, {}),
+    [publicPostTypes]
+  );
+  const needsUniqueIdentifier = (0, import_element.useCallback)(
+    ({ labels, slug }) => {
+      const singularName = labels.singular_name.toLowerCase();
+      return postTypeLabels[singularName] > 1 && singularName !== slug;
+    },
+    [postTypeLabels]
+  );
+  return (0, import_element.useMemo)(
+    () => postTypesWithArchives?.filter(
+      (postType) => !(existingTemplates || []).some(
+        (existingTemplate) => existingTemplate.slug === "archive-" + postType.slug
+      )
+    ).map((postType) => {
+      let title;
+      if (needsUniqueIdentifier(postType)) {
+        title = (0, import_i18n.sprintf)(
+          // translators: %1s: Name of the post type e.g: "Post"; %2s: Slug of the post type e.g: "book".
+          (0, import_i18n.__)("Archive: %1$s (%2$s)"),
+          postType.labels.singular_name,
+          postType.slug
+        );
+      } else {
+        title = (0, import_i18n.sprintf)(
+          // translators: %s: Name of the post type e.g: "Post".
+          (0, import_i18n.__)("Archive: %s"),
+          postType.labels.singular_name
+        );
+      }
+      return {
+        slug: "archive-" + postType.slug,
+        description: (0, import_i18n.sprintf)(
+          // translators: %s: Name of the post type e.g: "Post".
+          (0, import_i18n.__)(
+            "Displays an archive with the latest posts of type: %s."
+          ),
+          postType.labels.singular_name
+        ),
+        title,
+        // `icon` is the `menu_icon` property of a post type. We
+        // only handle `dashicons` for now, even if the `menu_icon`
+        // also supports urls and svg as values.
+        icon: typeof postType.icon === "string" && postType.icon.startsWith("dashicons-") ? postType.icon.slice(10) : import_icons.archive,
+        templatePrefix: "archive"
+      };
+    }) || [],
+    [postTypesWithArchives, existingTemplates, needsUniqueIdentifier]
+  );
 }
-const usePostTypeMenuItems = onClickMenuItem => {
+const usePostTypeMenuItems = (onClickMenuItem) => {
   const publicPostTypes = usePublicPostTypes();
   const defaultTemplateTypes = useDefaultTemplateTypes();
-  // We need to keep track of naming conflicts. If a conflict
-  // occurs, we need to add slug.
-  const templateLabels = (0, _element.useMemo)(() => publicPostTypes?.reduce((accumulator, {
-    labels
-  }) => {
-    const templateName = (labels.template_name || labels.singular_name).toLowerCase();
-    accumulator[templateName] = (accumulator[templateName] || 0) + 1;
-    return accumulator;
-  }, {}), [publicPostTypes]);
-  const needsUniqueIdentifier = (0, _element.useCallback)(({
-    labels,
-    slug
-  }) => {
-    const templateName = (labels.template_name || labels.singular_name).toLowerCase();
-    return templateLabels[templateName] > 1 && templateName !== slug;
-  }, [templateLabels]);
-
-  // `page`is a special case in template hierarchy.
-  const templatePrefixes = (0, _element.useMemo)(() => publicPostTypes?.reduce((accumulator, {
-    slug
-  }) => {
-    let suffix = slug;
-    if (slug !== 'page') {
-      suffix = `single-${suffix}`;
-    }
-    accumulator[slug] = suffix;
-    return accumulator;
-  }, {}), [publicPostTypes]);
-  const postTypesInfo = useEntitiesInfo('postType', templatePrefixes);
-  const menuItems = (publicPostTypes || []).reduce((accumulator, postType) => {
-    const {
-      slug,
-      labels,
-      icon
-    } = postType;
-    // We need to check if the general template is part of the
-    // defaultTemplateTypes. If it is, just use that info and
-    // augment it with the specific template functionality.
-    const generalTemplateSlug = templatePrefixes[slug];
-    const defaultTemplateType = defaultTemplateTypes?.find(({
-      slug: _slug
-    }) => _slug === generalTemplateSlug);
-    const _needsUniqueIdentifier = needsUniqueIdentifier(postType);
-    let menuItemTitle = labels.template_name || (0, _i18n.sprintf)(
-    // translators: %s: Name of the post type e.g: "Post".
-    (0, _i18n.__)('Single item: %s'), labels.singular_name);
-    if (_needsUniqueIdentifier) {
-      menuItemTitle = labels.template_name ? (0, _i18n.sprintf)(
-      // translators: 1: Name of the template e.g: "Single Item: Post". 2: Slug of the post type e.g: "book".
-      (0, _i18n._x)('%1$s (%2$s)', 'post type menu label'), labels.template_name, slug) : (0, _i18n.sprintf)(
-      // translators: 1: Name of the post type e.g: "Post". 2: Slug of the post type e.g: "book".
-      (0, _i18n._x)('Single item: %1$s (%2$s)', 'post type menu label'), labels.singular_name, slug);
-    }
-    const menuItem = defaultTemplateType ? {
-      ...defaultTemplateType,
-      templatePrefix: templatePrefixes[slug]
-    } : {
-      slug: generalTemplateSlug,
-      title: menuItemTitle,
-      description: (0, _i18n.sprintf)(
-      // translators: %s: Name of the post type e.g: "Post".
-      (0, _i18n.__)('Displays a single item: %s.'), labels.singular_name),
-      // `icon` is the `menu_icon` property of a post type. We
-      // only handle `dashicons` for now, even if the `menu_icon`
-      // also supports urls and svg as values.
-      icon: typeof icon === 'string' && icon.startsWith('dashicons-') ? icon.slice(10) : _icons.post,
-      templatePrefix: templatePrefixes[slug]
-    };
-    const hasEntities = postTypesInfo?.[slug]?.hasEntities;
-    // We have a different template creation flow only if they have entities.
-    if (hasEntities) {
-      menuItem.onClick = template => {
-        onClickMenuItem({
-          type: 'postType',
-          slug,
-          config: {
-            recordNamePath: 'title.rendered',
-            queryArgs: ({
-              search
-            }) => {
-              return {
-                _fields: 'id,title,slug,link',
-                orderBy: search ? 'relevance' : 'modified',
-                exclude: postTypesInfo[slug].existingEntitiesIds
-              };
-            },
-            getSpecificTemplate: suggestion => {
-              const templateSlug = prefixSlug(templatePrefixes[slug], suggestion.slug);
-              return {
-                title: templateSlug,
-                slug: templateSlug,
-                templatePrefix: templatePrefixes[slug]
-              };
-            }
-          },
-          labels,
-          template
-        });
+  const templateLabels = (0, import_element.useMemo)(
+    () => publicPostTypes?.reduce((accumulator, { labels }) => {
+      const templateName = (labels.template_name || labels.singular_name).toLowerCase();
+      accumulator[templateName] = (accumulator[templateName] || 0) + 1;
+      return accumulator;
+    }, {}),
+    [publicPostTypes]
+  );
+  const needsUniqueIdentifier = (0, import_element.useCallback)(
+    ({ labels, slug }) => {
+      const templateName = (labels.template_name || labels.singular_name).toLowerCase();
+      return templateLabels[templateName] > 1 && templateName !== slug;
+    },
+    [templateLabels]
+  );
+  const templatePrefixes = (0, import_element.useMemo)(
+    () => publicPostTypes?.reduce((accumulator, { slug }) => {
+      let suffix = slug;
+      if (slug !== "page") {
+        suffix = `single-${suffix}`;
+      }
+      accumulator[slug] = suffix;
+      return accumulator;
+    }, {}),
+    [publicPostTypes]
+  );
+  const postTypesInfo = useEntitiesInfo("postType", templatePrefixes);
+  const menuItems = (publicPostTypes || []).reduce(
+    (accumulator, postType) => {
+      const { slug, labels, icon } = postType;
+      const generalTemplateSlug = templatePrefixes[slug];
+      const defaultTemplateType = defaultTemplateTypes?.find(
+        ({ slug: _slug }) => _slug === generalTemplateSlug
+      );
+      const _needsUniqueIdentifier = needsUniqueIdentifier(postType);
+      let menuItemTitle = labels.template_name || (0, import_i18n.sprintf)(
+        // translators: %s: Name of the post type e.g: "Post".
+        (0, import_i18n.__)("Single item: %s"),
+        labels.singular_name
+      );
+      if (_needsUniqueIdentifier) {
+        menuItemTitle = labels.template_name ? (0, import_i18n.sprintf)(
+          // translators: 1: Name of the template e.g: "Single Item: Post". 2: Slug of the post type e.g: "book".
+          (0, import_i18n._x)("%1$s (%2$s)", "post type menu label"),
+          labels.template_name,
+          slug
+        ) : (0, import_i18n.sprintf)(
+          // translators: 1: Name of the post type e.g: "Post". 2: Slug of the post type e.g: "book".
+          (0, import_i18n._x)(
+            "Single item: %1$s (%2$s)",
+            "post type menu label"
+          ),
+          labels.singular_name,
+          slug
+        );
+      }
+      const menuItem = defaultTemplateType ? {
+        ...defaultTemplateType,
+        templatePrefix: templatePrefixes[slug]
+      } : {
+        slug: generalTemplateSlug,
+        title: menuItemTitle,
+        description: (0, import_i18n.sprintf)(
+          // translators: %s: Name of the post type e.g: "Post".
+          (0, import_i18n.__)("Displays a single item: %s."),
+          labels.singular_name
+        ),
+        // `icon` is the `menu_icon` property of a post type. We
+        // only handle `dashicons` for now, even if the `menu_icon`
+        // also supports urls and svg as values.
+        icon: typeof icon === "string" && icon.startsWith("dashicons-") ? icon.slice(10) : import_icons.post,
+        templatePrefix: templatePrefixes[slug]
       };
-    }
-    // We don't need to add the menu item if there are no entities.
-    if (hasEntities) {
-      accumulator.push(menuItem);
-    }
-    return accumulator;
-  }, []);
-  // Split menu items into two groups: one for the default post types
-  // and one for the rest.
-  const postTypesMenuItems = (0, _element.useMemo)(() => menuItems.reduce((accumulator, postType) => {
-    const {
-      slug
-    } = postType;
-    let key = 'postTypesMenuItems';
-    if (slug === 'page') {
-      key = 'defaultPostTypesMenuItems';
-    }
-    accumulator[key].push(postType);
-    return accumulator;
-  }, {
-    defaultPostTypesMenuItems: [],
-    postTypesMenuItems: []
-  }), [menuItems]);
+      const hasEntities = postTypesInfo?.[slug]?.hasEntities;
+      if (hasEntities) {
+        menuItem.onClick = (template) => {
+          onClickMenuItem({
+            type: "postType",
+            slug,
+            config: {
+              recordNamePath: "title.rendered",
+              queryArgs: ({ search }) => {
+                return {
+                  _fields: "id,title,slug,link",
+                  orderBy: search ? "relevance" : "modified",
+                  exclude: postTypesInfo[slug].existingEntitiesIds
+                };
+              },
+              getSpecificTemplate: (suggestion) => {
+                const templateSlug = prefixSlug(
+                  templatePrefixes[slug],
+                  suggestion.slug
+                );
+                return {
+                  title: templateSlug,
+                  slug: templateSlug,
+                  templatePrefix: templatePrefixes[slug]
+                };
+              }
+            },
+            labels,
+            template
+          });
+        };
+      }
+      if (hasEntities) {
+        accumulator.push(menuItem);
+      }
+      return accumulator;
+    },
+    []
+  );
+  const postTypesMenuItems = (0, import_element.useMemo)(
+    () => menuItems.reduce(
+      (accumulator, postType) => {
+        const { slug } = postType;
+        let key = "postTypesMenuItems";
+        if (slug === "page") {
+          key = "defaultPostTypesMenuItems";
+        }
+        accumulator[key].push(postType);
+        return accumulator;
+      },
+      { defaultPostTypesMenuItems: [], postTypesMenuItems: [] }
+    ),
+    [menuItems]
+  );
   return postTypesMenuItems;
 };
-exports.usePostTypeMenuItems = usePostTypeMenuItems;
-const useTaxonomiesMenuItems = onClickMenuItem => {
+const useTaxonomiesMenuItems = (onClickMenuItem) => {
   const publicTaxonomies = usePublicTaxonomies();
   const existingTemplates = useExistingTemplates();
   const defaultTemplateTypes = useDefaultTemplateTypes();
-  // `category` and `post_tag` are special cases in template hierarchy.
-  const templatePrefixes = (0, _element.useMemo)(() => publicTaxonomies?.reduce((accumulator, {
-    slug
-  }) => {
-    let suffix = slug;
-    if (!['category', 'post_tag'].includes(slug)) {
-      suffix = `taxonomy-${suffix}`;
-    }
-    if (slug === 'post_tag') {
-      suffix = `tag`;
-    }
-    accumulator[slug] = suffix;
-    return accumulator;
-  }, {}), [publicTaxonomies]);
-  // We need to keep track of naming conflicts. If a conflict
-  // occurs, we need to add slug.
-  const taxonomyLabels = publicTaxonomies?.reduce((accumulator, {
-    labels
-  }) => {
-    const templateName = (labels.template_name || labels.singular_name).toLowerCase();
-    accumulator[templateName] = (accumulator[templateName] || 0) + 1;
-    return accumulator;
-  }, {});
+  const templatePrefixes = (0, import_element.useMemo)(
+    () => publicTaxonomies?.reduce((accumulator, { slug }) => {
+      let suffix = slug;
+      if (!["category", "post_tag"].includes(slug)) {
+        suffix = `taxonomy-${suffix}`;
+      }
+      if (slug === "post_tag") {
+        suffix = `tag`;
+      }
+      accumulator[slug] = suffix;
+      return accumulator;
+    }, {}),
+    [publicTaxonomies]
+  );
+  const taxonomyLabels = publicTaxonomies?.reduce(
+    (accumulator, { labels }) => {
+      const templateName = (labels.template_name || labels.singular_name).toLowerCase();
+      accumulator[templateName] = (accumulator[templateName] || 0) + 1;
+      return accumulator;
+    },
+    {}
+  );
   const needsUniqueIdentifier = (labels, slug) => {
-    if (['category', 'post_tag'].includes(slug)) {
+    if (["category", "post_tag"].includes(slug)) {
       return false;
     }
     const templateName = (labels.template_name || labels.singular_name).toLowerCase();
     return taxonomyLabels[templateName] > 1 && templateName !== slug;
   };
-  const taxonomiesInfo = useEntitiesInfo('taxonomy', templatePrefixes);
-  const existingTemplateSlugs = (existingTemplates || []).map(({
-    slug
-  }) => slug);
-  const menuItems = (publicTaxonomies || []).reduce((accumulator, taxonomy) => {
-    const {
-      slug,
-      labels
-    } = taxonomy;
-    // We need to check if the general template is part of the
-    // defaultTemplateTypes. If it is, just use that info and
-    // augment it with the specific template functionality.
-    const generalTemplateSlug = templatePrefixes[slug];
-    const defaultTemplateType = defaultTemplateTypes?.find(({
-      slug: _slug
-    }) => _slug === generalTemplateSlug);
-    const hasGeneralTemplate = existingTemplateSlugs?.includes(generalTemplateSlug);
-    const _needsUniqueIdentifier = needsUniqueIdentifier(labels, slug);
-    let menuItemTitle = labels.template_name || labels.singular_name;
-    if (_needsUniqueIdentifier) {
-      menuItemTitle = labels.template_name ? (0, _i18n.sprintf)(
-      // translators: 1: Name of the template e.g: "Products by Category". 2: Slug of the taxonomy e.g: "product_cat".
-      (0, _i18n._x)('%1$s (%2$s)', 'taxonomy template menu label'), labels.template_name, slug) : (0, _i18n.sprintf)(
-      // translators: 1: Name of the taxonomy e.g: "Category". 2: Slug of the taxonomy e.g: "product_cat".
-      (0, _i18n._x)('%1$s (%2$s)', 'taxonomy menu label'), labels.singular_name, slug);
-    }
-    const menuItem = defaultTemplateType ? {
-      ...defaultTemplateType,
-      templatePrefix: templatePrefixes[slug]
-    } : {
-      slug: generalTemplateSlug,
-      title: menuItemTitle,
-      description: (0, _i18n.sprintf)(
-      // translators: %s: Name of the taxonomy e.g: "Product Categories".
-      (0, _i18n.__)('Displays taxonomy: %s.'), labels.singular_name),
-      icon: _icons.blockMeta,
-      templatePrefix: templatePrefixes[slug]
-    };
-    const hasEntities = taxonomiesInfo?.[slug]?.hasEntities;
-    // We have a different template creation flow only if they have entities.
-    if (hasEntities) {
-      menuItem.onClick = template => {
-        onClickMenuItem({
-          type: 'taxonomy',
-          slug,
-          config: {
-            queryArgs: ({
-              search
-            }) => {
-              return {
-                _fields: 'id,name,slug,link',
-                orderBy: search ? 'name' : 'count',
-                exclude: taxonomiesInfo[slug].existingEntitiesIds
-              };
-            },
-            getSpecificTemplate: suggestion => {
-              const templateSlug = prefixSlug(templatePrefixes[slug], suggestion.slug);
-              return {
-                title: templateSlug,
-                slug: templateSlug,
-                templatePrefix: templatePrefixes[slug]
-              };
-            }
-          },
-          labels,
-          hasGeneralTemplate,
-          template
-        });
+  const taxonomiesInfo = useEntitiesInfo("taxonomy", templatePrefixes);
+  const existingTemplateSlugs = (existingTemplates || []).map(
+    ({ slug }) => slug
+  );
+  const menuItems = (publicTaxonomies || []).reduce(
+    (accumulator, taxonomy) => {
+      const { slug, labels } = taxonomy;
+      const generalTemplateSlug = templatePrefixes[slug];
+      const defaultTemplateType = defaultTemplateTypes?.find(
+        ({ slug: _slug }) => _slug === generalTemplateSlug
+      );
+      const hasGeneralTemplate = existingTemplateSlugs?.includes(generalTemplateSlug);
+      const _needsUniqueIdentifier = needsUniqueIdentifier(
+        labels,
+        slug
+      );
+      let menuItemTitle = labels.template_name || labels.singular_name;
+      if (_needsUniqueIdentifier) {
+        menuItemTitle = labels.template_name ? (0, import_i18n.sprintf)(
+          // translators: 1: Name of the template e.g: "Products by Category". 2: Slug of the taxonomy e.g: "product_cat".
+          (0, import_i18n._x)("%1$s (%2$s)", "taxonomy template menu label"),
+          labels.template_name,
+          slug
+        ) : (0, import_i18n.sprintf)(
+          // translators: 1: Name of the taxonomy e.g: "Category". 2: Slug of the taxonomy e.g: "product_cat".
+          (0, import_i18n._x)("%1$s (%2$s)", "taxonomy menu label"),
+          labels.singular_name,
+          slug
+        );
+      }
+      const menuItem = defaultTemplateType ? {
+        ...defaultTemplateType,
+        templatePrefix: templatePrefixes[slug]
+      } : {
+        slug: generalTemplateSlug,
+        title: menuItemTitle,
+        description: (0, import_i18n.sprintf)(
+          // translators: %s: Name of the taxonomy e.g: "Product Categories".
+          (0, import_i18n.__)("Displays taxonomy: %s."),
+          labels.singular_name
+        ),
+        icon: import_icons.blockMeta,
+        templatePrefix: templatePrefixes[slug]
       };
-    }
-    // We don't need to add the menu item if there are no
-    // entities and the general template exists.
-    if (!hasGeneralTemplate || hasEntities) {
-      accumulator.push(menuItem);
-    }
-    return accumulator;
-  }, []);
-  // Split menu items into two groups: one for the default taxonomies
-  // and one for the rest.
-  const taxonomiesMenuItems = (0, _element.useMemo)(() => menuItems.reduce((accumulator, taxonomy) => {
-    const {
-      slug
-    } = taxonomy;
-    let key = 'taxonomiesMenuItems';
-    if (['category', 'tag'].includes(slug)) {
-      key = 'defaultTaxonomiesMenuItems';
-    }
-    accumulator[key].push(taxonomy);
-    return accumulator;
-  }, {
-    defaultTaxonomiesMenuItems: [],
-    taxonomiesMenuItems: []
-  }), [menuItems]);
+      const hasEntities = taxonomiesInfo?.[slug]?.hasEntities;
+      if (hasEntities) {
+        menuItem.onClick = (template) => {
+          onClickMenuItem({
+            type: "taxonomy",
+            slug,
+            config: {
+              queryArgs: ({ search }) => {
+                return {
+                  _fields: "id,name,slug,link",
+                  orderBy: search ? "name" : "count",
+                  exclude: taxonomiesInfo[slug].existingEntitiesIds
+                };
+              },
+              getSpecificTemplate: (suggestion) => {
+                const templateSlug = prefixSlug(
+                  templatePrefixes[slug],
+                  suggestion.slug
+                );
+                return {
+                  title: templateSlug,
+                  slug: templateSlug,
+                  templatePrefix: templatePrefixes[slug]
+                };
+              }
+            },
+            labels,
+            hasGeneralTemplate,
+            template
+          });
+        };
+      }
+      if (!hasGeneralTemplate || hasEntities) {
+        accumulator.push(menuItem);
+      }
+      return accumulator;
+    },
+    []
+  );
+  const taxonomiesMenuItems = (0, import_element.useMemo)(
+    () => menuItems.reduce(
+      (accumulator, taxonomy) => {
+        const { slug } = taxonomy;
+        let key = "taxonomiesMenuItems";
+        if (["category", "tag"].includes(slug)) {
+          key = "defaultTaxonomiesMenuItems";
+        }
+        accumulator[key].push(taxonomy);
+        return accumulator;
+      },
+      { defaultTaxonomiesMenuItems: [], taxonomiesMenuItems: [] }
+    ),
+    [menuItems]
+  );
   return taxonomiesMenuItems;
 };
-exports.useTaxonomiesMenuItems = useTaxonomiesMenuItems;
-const USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX = {
-  user: 'author'
-};
-const USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS = {
-  user: {
-    who: 'authors'
-  }
-};
+const USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX = { user: "author" };
+const USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS = { user: { who: "authors" } };
 function useAuthorMenuItem(onClickMenuItem) {
   const existingTemplates = useExistingTemplates();
   const defaultTemplateTypes = useDefaultTemplateTypes();
-  const authorInfo = useEntitiesInfo('root', USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX, USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS);
-  let authorMenuItem = defaultTemplateTypes?.find(({
-    slug
-  }) => slug === 'author');
+  const authorInfo = useEntitiesInfo(
+    "root",
+    USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX,
+    USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS
+  );
+  let authorMenuItem = defaultTemplateTypes?.find(
+    ({ slug }) => slug === "author"
+  );
   if (!authorMenuItem) {
     authorMenuItem = {
-      description: (0, _i18n.__)('Displays latest posts written by a single author.'),
-      slug: 'author',
-      title: 'Author'
+      description: (0, import_i18n.__)(
+        "Displays latest posts written by a single author."
+      ),
+      slug: "author",
+      title: "Author"
     };
   }
-  const hasGeneralTemplate = !!existingTemplates?.find(({
-    slug
-  }) => slug === 'author');
+  const hasGeneralTemplate = !!existingTemplates?.find(
+    ({ slug }) => slug === "author"
+  );
   if (authorInfo.user?.hasEntities) {
-    authorMenuItem = {
-      ...authorMenuItem,
-      templatePrefix: 'author'
-    };
-    authorMenuItem.onClick = template => {
+    authorMenuItem = { ...authorMenuItem, templatePrefix: "author" };
+    authorMenuItem.onClick = (template) => {
       onClickMenuItem({
-        type: 'root',
-        slug: 'user',
+        type: "root",
+        slug: "user",
         config: {
-          queryArgs: ({
-            search
-          }) => {
+          queryArgs: ({ search }) => {
             return {
-              _fields: 'id,name,slug,link',
-              orderBy: search ? 'name' : 'registered_date',
+              _fields: "id,name,slug,link",
+              orderBy: search ? "name" : "registered_date",
               exclude: authorInfo.user.existingEntitiesIds,
-              who: 'authors'
+              who: "authors"
             };
           },
-          getSpecificTemplate: suggestion => {
-            const templateSlug = prefixSlug('author', suggestion.slug);
+          getSpecificTemplate: (suggestion) => {
+            const templateSlug = prefixSlug(
+              "author",
+              suggestion.slug
+            );
             return {
-              title: (0, _i18n.sprintf)(
-              // translators: %s: Name of the author e.g: "Admin".
-              (0, _i18n.__)('Author: %s'), suggestion.name),
+              title: (0, import_i18n.sprintf)(
+                // translators: %s: Name of the author e.g: "Admin".
+                (0, import_i18n.__)("Author: %s"),
+                suggestion.name
+              ),
               slug: templateSlug,
-              templatePrefix: 'author'
+              templatePrefix: "author"
             };
           }
         },
         labels: {
-          singular_name: (0, _i18n.__)('Author'),
-          search_items: (0, _i18n.__)('Search Authors'),
-          not_found: (0, _i18n.__)('No authors found.'),
-          all_items: (0, _i18n.__)('All Authors')
+          singular_name: (0, import_i18n.__)("Author"),
+          search_items: (0, import_i18n.__)("Search Authors"),
+          not_found: (0, import_i18n.__)("No authors found."),
+          all_items: (0, import_i18n.__)("All Authors")
         },
         hasGeneralTemplate,
         template
@@ -489,42 +497,47 @@ function useAuthorMenuItem(onClickMenuItem) {
     return authorMenuItem;
   }
 }
-
-/**
- * Helper hook that returns information about an entity having
- * records that we can create a specific template for.
- *
- * For example we can search for `terms` in `taxonomy` entity or
- * `posts` in `postType` entity.
- *
- * First we need to find the existing records with an associated template,
- * to query afterwards for any remaining record, by excluding them.
- *
- * @param {string}                entityName                The entity's name.
- * @param {Record<string,string>} templatePrefixes          An object with the entity's slug as key and the template prefix as value.
- * @param {Record<string,Object>} additionalQueryParameters An object with the entity's slug as key and additional query parameters as value.
- * @return {Record<string,EntitiesInfo>} An object with the entity's slug as key and the EntitiesInfo as value.
- */
 const useEntitiesInfo = (entityName, templatePrefixes, additionalQueryParameters = EMPTY_OBJECT) => {
-  const entitiesHasRecords = (0, _data.useSelect)(select => {
-    return Object.keys(templatePrefixes || {}).reduce((accumulator, slug) => {
-      accumulator[slug] = !!select(_coreData.store).getEntityRecords(entityName, slug, {
-        per_page: 1,
-        _fields: 'id',
-        context: 'view',
-        ...additionalQueryParameters[slug]
-      })?.length;
-      return accumulator;
-    }, {});
-  }, [templatePrefixes, entityName, additionalQueryParameters]);
-  const entitiesInfo = (0, _element.useMemo)(() => {
-    return Object.keys(templatePrefixes || {}).reduce((accumulator, slug) => {
-      accumulator[slug] = {
-        hasEntities: entitiesHasRecords[slug]
-      };
-      return accumulator;
-    }, {});
+  const entitiesHasRecords = (0, import_data.useSelect)(
+    (select) => {
+      return Object.keys(templatePrefixes || {}).reduce(
+        (accumulator, slug) => {
+          accumulator[slug] = !!select(
+            import_core_data.store
+          ).getEntityRecords(entityName, slug, {
+            per_page: 1,
+            _fields: "id",
+            context: "view",
+            ...additionalQueryParameters[slug]
+          })?.length;
+          return accumulator;
+        },
+        {}
+      );
+    },
+    [templatePrefixes, entityName, additionalQueryParameters]
+  );
+  const entitiesInfo = (0, import_element.useMemo)(() => {
+    return Object.keys(templatePrefixes || {}).reduce(
+      (accumulator, slug) => {
+        accumulator[slug] = {
+          hasEntities: entitiesHasRecords[slug]
+        };
+        return accumulator;
+      },
+      {}
+    );
   }, [templatePrefixes, entitiesHasRecords]);
   return entitiesInfo;
 };
-//# sourceMappingURL=utils.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapToIHasNameAndId,
+  useAuthorMenuItem,
+  useDefaultTemplateTypes,
+  useExistingTemplates,
+  usePostTypeArchiveMenuItems,
+  usePostTypeMenuItems,
+  useTaxonomiesMenuItems
+});
+//# sourceMappingURL=utils.js.map