@wordpress/edit-site 4.9.0 → 4.12.0

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

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.usePostTypesEntitiesInfo = exports.usePostTypes = exports.mapToIHasNameAndId = void 0;
+exports.mapToIHasNameAndId = void 0;
+exports.useAuthorMenuItem = useAuthorMenuItem;
+exports.useTaxonomiesMenuItems = exports.usePostTypeMenuItems = exports.useExistingTemplates = exports.useDefaultTemplateTypes = void 0;
 
 var _lodash = require("lodash");
 
@@ -11,10 +13,16 @@ var _data = require("@wordpress/data");
 
 var _coreData = require("@wordpress/core-data");
 
+var _editor = require("@wordpress/editor");
+
 var _htmlEntities = require("@wordpress/html-entities");
 
 var _element = require("@wordpress/element");
 
+var _i18n = require("@wordpress/i18n");
+
+var _icons = require("@wordpress/icons");
+
 /**
  * External dependencies
  */
@@ -22,12 +30,56 @@ var _element = require("@wordpress/element");
 /**
  * WordPress dependencies
  */
-const usePostTypes = () => {
+
+/**
+ * @typedef IHasNameAndId
+ * @property {string|number} id   The entity's id.
+ * @property {string}        name The entity's name.
+ */
+
+/**
+ * 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 enitities that now implement the `IHasNameAndId` interface.
+ */
+const mapToIHasNameAndId = (entities, path) => {
+  return (entities || []).map(entity => ({ ...entity,
+    name: (0, _htmlEntities.decodeEntities)((0, _lodash.get)(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', 'wp_template', {
+    per_page: -1
+  }), []);
+};
+
+exports.useExistingTemplates = useExistingTemplates;
+
+const useDefaultTemplateTypes = () => {
+  return (0, _data.useSelect)(select => select(_editor.store).__experimentalGetDefaultTemplateTypes(), []);
+};
+
+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', 'page'];
+    const excludedPostTypes = ['attachment'];
     return postTypes === null || postTypes === void 0 ? void 0 : postTypes.filter(_ref => {
       let {
         viewable,
@@ -37,103 +89,568 @@ const usePostTypes = () => {
     });
   }, [postTypes]);
 };
-/**
- * @typedef {Object} PostTypeEntitiesInfo
- * @property {boolean}  hasEntities   If a postType has available entities.
- * @property {number[]} existingPosts An array of the existing entities ids.
- */
 
+const usePublicTaxonomies = () => {
+  const taxonomies = (0, _data.useSelect)(select => select(_coreData.store).getTaxonomies({
+    per_page: -1
+  }), []);
+  return (0, _element.useMemo)(() => {
+    return taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref2 => {
+      let {
+        visibility
+      } = _ref2;
+      return visibility === null || visibility === void 0 ? void 0 : visibility.publicly_queryable;
+    });
+  }, [taxonomies]);
+};
+
+const usePostTypeMenuItems = onClickMenuItem => {
+  const publicPostTypes = usePublicPostTypes();
+  const existingTemplates = useExistingTemplates();
+  const defaultTemplateTypes = useDefaultTemplateTypes(); // `page`is a special case in template hierarchy.
+
+  const templatePrefixes = (0, _element.useMemo)(() => publicPostTypes === null || publicPostTypes === void 0 ? void 0 : publicPostTypes.reduce((accumulator, _ref3) => {
+    let {
+      slug
+    } = _ref3;
+    let suffix = slug;
+
+    if (slug !== 'page') {
+      suffix = `single-${suffix}`;
+    }
+
+    accumulator[slug] = suffix;
+    return accumulator;
+  }, {}), [publicPostTypes]); // We need to keep track of naming conflicts. If a conflict
+  // occurs, we need to add slug.
+
+  const postTypeLabels = publicPostTypes === null || publicPostTypes === void 0 ? void 0 : publicPostTypes.reduce((accumulator, _ref4) => {
+    let {
+      labels
+    } = _ref4;
+    const singularName = labels.singular_name.toLowerCase();
+    accumulator[singularName] = (accumulator[singularName] || 0) + 1;
+    return accumulator;
+  }, {});
+
+  const needsUniqueIdentifier = (labels, slug) => {
+    const singularName = labels.singular_name.toLowerCase();
+    return postTypeLabels[singularName] > 1 && singularName !== slug;
+  };
+
+  const postTypesInfo = useEntitiesInfo('postType', templatePrefixes);
+  const existingTemplateSlugs = (existingTemplates || []).map(_ref5 => {
+    let {
+      slug
+    } = _ref5;
+    return slug;
+  });
+  const menuItems = (publicPostTypes || []).reduce((accumulator, postType) => {
+    var _postTypesInfo$slug;
+
+    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 === null || defaultTemplateTypes === void 0 ? void 0 : defaultTemplateTypes.find(_ref6 => {
+      let {
+        slug: _slug
+      } = _ref6;
+      return _slug === generalTemplateSlug;
+    });
+    const hasGeneralTemplate = existingTemplateSlugs === null || existingTemplateSlugs === void 0 ? void 0 : existingTemplateSlugs.includes(generalTemplateSlug);
+
+    const _needsUniqueIdentifier = needsUniqueIdentifier(labels, slug);
+
+    let menuItemTitle = (0, _i18n.sprintf)( // translators: %s: Name of the post type e.g: "Post".
+    (0, _i18n.__)('Single item: %s'), labels.singular_name);
+
+    if (_needsUniqueIdentifier) {
+      menuItemTitle = (0, _i18n.sprintf)( // translators: %1s: Name of the post type e.g: "Post"; %2s: Slug of the post type e.g: "book".
+      (0, _i18n.__)('Single item: %1$s (%2$s)'), 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: icon !== null && icon !== void 0 && icon.startsWith('dashicons-') ? icon.slice(10) : _icons.post,
+      templatePrefix: templatePrefixes[slug]
+    };
+    const hasEntities = postTypesInfo === null || postTypesInfo === void 0 ? void 0 : (_postTypesInfo$slug = postTypesInfo[slug]) === null || _postTypesInfo$slug === void 0 ? void 0 : _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: _ref7 => {
+              let {
+                search
+              } = _ref7;
+              return {
+                _fields: 'id,title,slug,link',
+                orderBy: search ? 'relevance' : 'modified',
+                exclude: postTypesInfo[slug].existingEntitiesIds
+              };
+            },
+            getSpecificTemplate: suggestion => {
+              let title = (0, _i18n.sprintf)( // translators: Represents the title of a user's custom template in the Site Editor, where %1$s is the singular name of a post type and %2$s is the name of the post, e.g. "Page: Hello".
+              (0, _i18n.__)('%1$s: %2$s'), labels.singular_name, suggestion.name);
+              const description = (0, _i18n.sprintf)( // translators: Represents the description of a user's custom template in the Site Editor, e.g. "Template for Page: Hello"
+              (0, _i18n.__)('Template for %1$s'), title);
+
+              if (_needsUniqueIdentifier) {
+                title = (0, _i18n.sprintf)( // translators: Represents the title of a user's custom template in the Site Editor, where %1$s is the template title and %2$s is the slug of the post type, e.g. "Project: Hello (project_type)"
+                (0, _i18n.__)('%1$s (%2$s)'), title, slug);
+              }
+
+              return {
+                title,
+                description,
+                slug: `${templatePrefixes[slug]}-${suggestion.slug}`,
+                templatePrefix: templatePrefixes[slug]
+              };
+            }
+          },
+          labels,
+          hasGeneralTemplate,
+          template
+        });
+      };
+    } // 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 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]);
+  return postTypesMenuItems;
+};
+
+exports.usePostTypeMenuItems = usePostTypeMenuItems;
+
+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 === null || publicTaxonomies === void 0 ? void 0 : publicTaxonomies.reduce((accumulator, _ref8) => {
+    let {
+      slug
+    } = _ref8;
+    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 === null || publicTaxonomies === void 0 ? void 0 : publicTaxonomies.reduce((accumulator, _ref9) => {
+    let {
+      labels
+    } = _ref9;
+    const singularName = labels.singular_name.toLowerCase();
+    accumulator[singularName] = (accumulator[singularName] || 0) + 1;
+    return accumulator;
+  }, {});
+
+  const needsUniqueIdentifier = (labels, slug) => {
+    if (['category', 'post_tag'].includes(slug)) {
+      return false;
+    }
+
+    const singularName = labels.singular_name.toLowerCase();
+    return taxonomyLabels[singularName] > 1 && singularName !== slug;
+  };
+
+  const taxonomiesInfo = useEntitiesInfo('taxonomy', templatePrefixes);
+  const existingTemplateSlugs = (existingTemplates || []).map(_ref10 => {
+    let {
+      slug
+    } = _ref10;
+    return slug;
+  });
+  const menuItems = (publicTaxonomies || []).reduce((accumulator, taxonomy) => {
+    var _taxonomiesInfo$slug;
+
+    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 === null || defaultTemplateTypes === void 0 ? void 0 : defaultTemplateTypes.find(_ref11 => {
+      let {
+        slug: _slug
+      } = _ref11;
+      return _slug === generalTemplateSlug;
+    });
+    const hasGeneralTemplate = existingTemplateSlugs === null || existingTemplateSlugs === void 0 ? void 0 : existingTemplateSlugs.includes(generalTemplateSlug);
+
+    const _needsUniqueIdentifier = needsUniqueIdentifier(labels, slug);
+
+    let menuItemTitle = labels.singular_name;
+
+    if (_needsUniqueIdentifier) {
+      menuItemTitle = (0, _i18n.sprintf)( // translators: %1s: Name of the taxonomy e.g: "Category"; %2s: Slug of the taxonomy e.g: "product_cat".
+      (0, _i18n.__)('%1$s (%2$s)'), 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 === null || taxonomiesInfo === void 0 ? void 0 : (_taxonomiesInfo$slug = taxonomiesInfo[slug]) === null || _taxonomiesInfo$slug === void 0 ? void 0 : _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: _ref12 => {
+              let {
+                search
+              } = _ref12;
+              return {
+                _fields: 'id,name,slug,link',
+                orderBy: search ? 'name' : 'count',
+                exclude: taxonomiesInfo[slug].existingEntitiesIds
+              };
+            },
+            getSpecificTemplate: suggestion => {
+              let title = (0, _i18n.sprintf)( // translators: Represents the title of a user's custom template in the Site Editor, where %1$s is the singular name of a taxonomy and %2$s is the name of the term, e.g. "Category: shoes".
+              (0, _i18n.__)('%1$s: %2$s'), labels.singular_name, suggestion.name);
+              const description = (0, _i18n.sprintf)( // translators: Represents the description of a user's custom template in the Site Editor, e.g. "Template for Category: shoes"
+              (0, _i18n.__)('Template for %1$s'), title);
+
+              if (_needsUniqueIdentifier) {
+                title = (0, _i18n.sprintf)( // translators: Represents the title of a user's custom template in the Site Editor, where %1$s is the template title and %2$s is the slug of the taxonomy, e.g. "Category: shoes (product_tag)"
+                (0, _i18n.__)('%1$s (%2$s)'), title, slug);
+              }
+
+              return {
+                title,
+                description,
+                slug: `${templatePrefixes[slug]}-${suggestion.slug}`,
+                templatePrefix: templatePrefixes[slug]
+              };
+            }
+          },
+          labels,
+          hasGeneralTemplate,
+          template
+        });
+      };
+    } // 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]);
+  return taxonomiesMenuItems;
+};
+
+exports.useTaxonomiesMenuItems = useTaxonomiesMenuItems;
+
+function useAuthorNeedsUniqueIndentifier() {
+  const authors = (0, _data.useSelect)(select => select(_coreData.store).getUsers({
+    who: 'authors',
+    per_page: -1
+  }), []);
+  const authorsCountByName = (0, _element.useMemo)(() => {
+    return (authors || []).reduce((authorsCount, _ref13) => {
+      let {
+        name
+      } = _ref13;
+      authorsCount[name] = (authorsCount[name] || 0) + 1;
+      return authorsCount;
+    }, {});
+  }, [authors]);
+  return (0, _element.useCallback)(name => {
+    return authorsCountByName[name] > 1;
+  }, [authorsCountByName]);
+}
+
+const USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX = {
+  user: 'author'
+};
+const USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS = {
+  user: {
+    who: 'authors'
+  }
+};
+
+function useAuthorMenuItem(onClickMenuItem) {
+  var _authorInfo$user, _authorInfo$user2;
+
+  const existingTemplates = useExistingTemplates();
+  const defaultTemplateTypes = useDefaultTemplateTypes();
+  const authorInfo = useEntitiesInfo('root', USE_AUTHOR_MENU_ITEM_TEMPLATE_PREFIX, USE_AUTHOR_MENU_ITEM_QUERY_PARAMETERS);
+  const authorNeedsUniqueId = useAuthorNeedsUniqueIndentifier();
+  let authorMenuItem = defaultTemplateTypes === null || defaultTemplateTypes === void 0 ? void 0 : defaultTemplateTypes.find(_ref14 => {
+    let {
+      slug
+    } = _ref14;
+    return slug === 'author';
+  });
+
+  if (!authorMenuItem) {
+    authorMenuItem = {
+      description: (0, _i18n.__)('Displays latest posts written by a single author.'),
+      slug: 'author',
+      title: 'Author'
+    };
+  }
+
+  const hasGeneralTemplate = !!(existingTemplates !== null && existingTemplates !== void 0 && existingTemplates.find(_ref15 => {
+    let {
+      slug
+    } = _ref15;
+    return slug === 'author';
+  }));
+
+  if ((_authorInfo$user = authorInfo.user) !== null && _authorInfo$user !== void 0 && _authorInfo$user.hasEntities) {
+    authorMenuItem = { ...authorMenuItem,
+      templatePrefix: 'author'
+    };
+
+    authorMenuItem.onClick = template => {
+      onClickMenuItem({
+        type: 'root',
+        slug: 'user',
+        config: {
+          queryArgs: _ref16 => {
+            let {
+              search
+            } = _ref16;
+            return {
+              _fields: 'id,name,slug,link',
+              orderBy: search ? 'name' : 'registered_date',
+              exclude: authorInfo.user.existingEntitiesIds,
+              who: 'authors'
+            };
+          },
+          getSpecificTemplate: suggestion => {
+            const needsUniqueId = authorNeedsUniqueId(suggestion.name);
+            const title = needsUniqueId ? (0, _i18n.sprintf)( // translators: %1$s: Represents the name of an author e.g: "Jorge", %2$s: Represents the slug of an author e.g: "author-jorge-slug".
+            (0, _i18n.__)('Author: %1$s (%2$s)'), suggestion.name, suggestion.slug) : (0, _i18n.sprintf)( // translators: %s: Represents the name of an author e.g: "Jorge".
+            (0, _i18n.__)('Author: %s'), suggestion.name);
+            const description = (0, _i18n.sprintf)( // translators: %s: Represents the name of an author e.g: "Jorge".
+            (0, _i18n.__)('Template for Author: %s'), suggestion.name);
+            return {
+              title,
+              description,
+              slug: `author-${suggestion.slug}`,
+              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')
+        },
+        hasGeneralTemplate,
+        template
+      });
+    };
+  }
+
+  if (!hasGeneralTemplate || (_authorInfo$user2 = authorInfo.user) !== null && _authorInfo$user2 !== void 0 && _authorInfo$user2.hasEntities) {
+    return authorMenuItem;
+  }
+}
 /**
- * Helper hook that returns information about a post type having
- * posts that we can create a specific template for.
+ * Helper hook that filters all the existing templates by the given
+ * object with the entity's slug as key and the template prefix as value.
  *
- * First we need to find the existing posts with an associated template,
- * to query afterwards for any remaing post, by excluding them.
+ * Example:
+ * `existingTemplates` is: [ { slug: 'tag-apple' }, { slug: 'page-about' }, { slug: 'tag' } ]
+ * `templatePrefixes` is: { post_tag: 'tag' }
+ * It will return: { post_tag: ['apple'] }
  *
- * @param {string[]} existingTemplates The existing templates.
- * @return {Record<string,PostTypeEntitiesInfo>} An object with the postTypes as `keys` and PostTypeEntitiesInfo as values.
+ * Note: We append the `-` to the given template prefix in this function for our checks.
+ *
+ * @param {Record<string,string>} templatePrefixes An object with the entity's slug as key and the template prefix as value.
+ * @return {Record<string,string[]>} An object with the entity's slug as key and an array with the existing template slugs as value.
  */
 
 
-exports.usePostTypes = usePostTypes;
-
-const usePostTypesEntitiesInfo = existingTemplates => {
-  const postTypes = usePostTypes();
-  const slugsToExcludePerEntity = (0, _element.useMemo)(() => {
-    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.reduce((accumulator, _postType) => {
+const useExistingTemplateSlugs = templatePrefixes => {
+  const existingTemplates = useExistingTemplates();
+  const existingSlugs = (0, _element.useMemo)(() => {
+    return Object.entries(templatePrefixes || {}).reduce((accumulator, _ref17) => {
+      let [slug, prefix] = _ref17;
       const slugsWithTemplates = (existingTemplates || []).reduce((_accumulator, existingTemplate) => {
-        const prefix = `single-${_postType.slug}-`;
+        const _prefix = `${prefix}-`;
 
-        if (existingTemplate.slug.startsWith(prefix)) {
-          _accumulator.push(existingTemplate.slug.substring(prefix.length));
+        if (existingTemplate.slug.startsWith(_prefix)) {
+          _accumulator.push(existingTemplate.slug.substring(_prefix.length));
         }
 
         return _accumulator;
       }, []);
 
       if (slugsWithTemplates.length) {
-        accumulator[_postType.slug] = slugsWithTemplates;
+        accumulator[slug] = slugsWithTemplates;
       }
 
       return accumulator;
     }, {});
-  }, [postTypes, existingTemplates]);
-  const postsToExcludePerEntity = (0, _data.useSelect)(select => {
-    if (!slugsToExcludePerEntity) {
-      return;
-    }
+  }, [templatePrefixes, existingTemplates]);
+  return existingSlugs;
+};
+/**
+ * Helper hook that finds the existing records with an associated template,
+ * as they need to be excluded from the template suggestions.
+ *
+ * @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 existing records as value.
+ */
 
-    const postsToExclude = Object.entries(slugsToExcludePerEntity).reduce((accumulator, _ref2) => {
-      let [slug, slugsWithTemplates] = _ref2;
-      const postsWithTemplates = select(_coreData.store).getEntityRecords('postType', slug, {
+
+const useTemplatesToExclude = function (entityName, templatePrefixes) {
+  let additionalQueryParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const slugsToExcludePerEntity = useExistingTemplateSlugs(templatePrefixes);
+  const recordsToExcludePerEntity = (0, _data.useSelect)(select => {
+    return Object.entries(slugsToExcludePerEntity || {}).reduce((accumulator, _ref18) => {
+      let [slug, slugsWithTemplates] = _ref18;
+      const entitiesWithTemplates = select(_coreData.store).getEntityRecords(entityName, slug, {
         _fields: 'id',
         context: 'view',
-        slug: slugsWithTemplates
+        slug: slugsWithTemplates,
+        ...additionalQueryParameters[slug]
       });
 
-      if (postsWithTemplates !== null && postsWithTemplates !== void 0 && postsWithTemplates.length) {
-        accumulator[slug] = postsWithTemplates;
+      if (entitiesWithTemplates !== null && entitiesWithTemplates !== void 0 && entitiesWithTemplates.length) {
+        accumulator[slug] = entitiesWithTemplates;
       }
 
       return accumulator;
     }, {});
-    return postsToExclude;
   }, [slugsToExcludePerEntity]);
+  return recordsToExcludePerEntity;
+};
+/**
+ * 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 = function (entityName, templatePrefixes) {
+  let additionalQueryParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const recordsToExcludePerEntity = useTemplatesToExclude(entityName, templatePrefixes, additionalQueryParameters);
   const entitiesInfo = (0, _data.useSelect)(select => {
-    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.reduce((accumulator, _ref3) => {
-      var _postsToExcludePerEnt, _select$getEntityReco;
+    return Object.keys(templatePrefixes || {}).reduce((accumulator, slug) => {
+      var _recordsToExcludePerE, _select$getEntityReco;
 
-      let {
-        slug
-      } = _ref3;
-      const existingPosts = (postsToExcludePerEntity === null || postsToExcludePerEntity === void 0 ? void 0 : (_postsToExcludePerEnt = postsToExcludePerEntity[slug]) === null || _postsToExcludePerEnt === void 0 ? void 0 : _postsToExcludePerEnt.map(_ref4 => {
+      const existingEntitiesIds = (recordsToExcludePerEntity === null || recordsToExcludePerEntity === void 0 ? void 0 : (_recordsToExcludePerE = recordsToExcludePerEntity[slug]) === null || _recordsToExcludePerE === void 0 ? void 0 : _recordsToExcludePerE.map(_ref19 => {
         let {
           id
-        } = _ref4;
+        } = _ref19;
         return id;
       })) || [];
       accumulator[slug] = {
-        hasEntities: !!((_select$getEntityReco = select(_coreData.store).getEntityRecords('postType', slug, {
+        hasEntities: !!((_select$getEntityReco = select(_coreData.store).getEntityRecords(entityName, slug, {
           per_page: 1,
           _fields: 'id',
           context: 'view',
-          exclude: existingPosts
+          exclude: existingEntitiesIds,
+          ...additionalQueryParameters[slug]
         })) !== null && _select$getEntityReco !== void 0 && _select$getEntityReco.length),
-        existingPosts
+        existingEntitiesIds
       };
       return accumulator;
     }, {});
-  }, [postTypes, postsToExcludePerEntity]);
+  }, [templatePrefixes, recordsToExcludePerEntity]);
   return entitiesInfo;
 };
-
-exports.usePostTypesEntitiesInfo = usePostTypesEntitiesInfo;
-
-const mapToIHasNameAndId = (entities, path) => {
-  return (entities || []).map(entity => ({ ...entity,
-    name: (0, _htmlEntities.decodeEntities)((0, _lodash.get)(entity, path))
-  }));
-};
-
-exports.mapToIHasNameAndId = mapToIHasNameAndId;
 //# sourceMappingURL=utils.js.map