@wordpress/edit-site 4.10.0 → 4.11.0

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

@@ -40,73 +40,6 @@ export const mapToIHasNameAndId = (entities, path) => {
  * @property {number[]} existingEntitiesIds An array of the existing entities ids.
  */
 
-/**
- * @typedef {Object} EntityConfig
- * @property {string}   entityName     The entity's name.
- * @property {Function} getOrderBy     Getter for an entity's `orderBy` query parameter, given the object
- *                                     {search} as argument.
- * @property {Function} getIcon        Getter function for returning an entity's icon for the menu item.
- * @property {Function} getTitle       Getter function for returning an entity's title for the menu item.
- * @property {Function} getDescription Getter function for returning an entity's description for the menu item.
- * @property {string}   recordNamePath The path to an entity's properties to use as a `name`. If not provided
- *                                     is assumed that `name` property exists.
- * @property {string}   templatePrefix The template prefix to create new templates and check against existing
- *                                     templates. For example custom post types need a `single-` prefix to all
- *                                     templates(`single-post-hello`), whereas `pages` don't (`page-hello`).
- * @property {string}   templateSlug   If this property is provided, it is going to be used for the creation of
- *                                     new templates and the check against existing templates in the place
- *                                     of the actual entity's `slug`. An example is `Tag` templates where the
- *                                     the Tag's taxonomy slug is `post_tag`, but template hierarchy is based
- *                                     on `tag` alias.
- */
-
-const taxonomyBaseConfig = {
-  entityName: 'taxonomy',
-  getOrderBy: _ref => {
-    let {
-      search
-    } = _ref;
-    return search ? 'name' : 'count';
-  },
-  getIcon: () => blockMeta,
-  getTitle: labels => sprintf( // translators: %s: Name of the taxonomy e.g: "Cagegory".
-  __('Single taxonomy: %s'), labels.singular_name),
-  getDescription: labels => sprintf( // translators: %s: Name of the taxonomy e.g: "Product Categories".
-  __('Displays a single taxonomy: %s.'), labels.singular_name)
-};
-const postTypeBaseConfig = {
-  entityName: 'postType',
-  getOrderBy: _ref2 => {
-    let {
-      search
-    } = _ref2;
-    return search ? 'relevance' : 'modified';
-  },
-  recordNamePath: 'title.rendered',
-  // `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.
-  getIcon: _icon => _icon !== null && _icon !== void 0 && _icon.startsWith('dashicons-') ? _icon.slice(10) : post,
-  getTitle: labels => sprintf( // translators: %s: Name of the post type e.g: "Post".
-  __('Single item: %s'), labels.singular_name),
-  getDescription: labels => sprintf( // translators: %s: Name of the post type e.g: "Post".
-  __('Displays a single item: %s.'), labels.singular_name)
-};
-export const entitiesConfig = {
-  postType: { ...postTypeBaseConfig,
-    templatePrefix: 'single-'
-  },
-  page: { ...postTypeBaseConfig
-  },
-  taxonomy: { ...taxonomyBaseConfig,
-    templatePrefix: 'taxonomy-'
-  },
-  category: { ...taxonomyBaseConfig
-  },
-  tag: { ...taxonomyBaseConfig,
-    templateSlug: 'tag'
-  }
-};
 export const useExistingTemplates = () => {
   return useSelect(select => select(coreStore).getEntityRecords('postType', 'wp_template', {
     per_page: -1
@@ -122,40 +55,14 @@ const usePublicPostTypes = () => {
   }), []);
   return useMemo(() => {
     const excludedPostTypes = ['attachment'];
-    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.filter(_ref3 => {
+    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.filter(_ref => {
       let {
         viewable,
         slug
-      } = _ref3;
+      } = _ref;
       return viewable && !excludedPostTypes.includes(slug);
     });
   }, [postTypes]);
-}; // `page` post type is a special case in the template hierarchy,
-// so we exclude it from the list of post types and we handle it
-// separately.
-
-
-export const usePostTypes = () => {
-  const postTypes = usePublicPostTypes();
-  return useMemo(() => {
-    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.filter(_ref4 => {
-      let {
-        slug
-      } = _ref4;
-      return slug !== 'page';
-    });
-  }, [postTypes]);
-};
-export const usePostTypePage = () => {
-  const postTypes = usePublicPostTypes();
-  return useMemo(() => {
-    return postTypes === null || postTypes === void 0 ? void 0 : postTypes.filter(_ref5 => {
-      let {
-        slug
-      } = _ref5;
-      return slug === 'page';
-    });
-  }, [postTypes]);
 };
 
 const usePublicTaxonomies = () => {
@@ -163,80 +70,348 @@ const usePublicTaxonomies = () => {
     per_page: -1
   }), []);
   return useMemo(() => {
-    return taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref6 => {
+    return taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref2 => {
       let {
         visibility
-      } = _ref6;
+      } = _ref2;
       return visibility === null || visibility === void 0 ? void 0 : visibility.publicly_queryable;
     });
   }, [taxonomies]);
 };
-/**
- * `category` and `post_tag` are handled specifically in template
- * hierarchy so we need to differentiate them and return the rest,
- * e.g. `category-$slug` and `taxonomy-$taxonomy-$term`.
- */
 
+export const usePostTypeMenuItems = onClickMenuItem => {
+  const publicPostTypes = usePublicPostTypes();
+  const existingTemplates = useExistingTemplates();
+  const defaultTemplateTypes = useDefaultTemplateTypes(); // `page`is a special case in template hierarchy.
 
-export const useTaxonomies = () => {
-  const taxonomies = usePublicTaxonomies();
-  const specialTaxonomies = ['category', 'post_tag'];
-  return useMemo(() => taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref7 => {
+  const templatePrefixes = useMemo(() => publicPostTypes === null || publicPostTypes === void 0 ? void 0 : publicPostTypes.reduce((accumulator, _ref3) => {
     let {
       slug
-    } = _ref7;
-    return !specialTaxonomies.includes(slug);
-  }), [taxonomies]);
-};
-export const useTaxonomyCategory = () => {
-  const taxonomies = usePublicTaxonomies();
-  return useMemo(() => taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref8 => {
+    } = _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
-    } = _ref8;
-    return slug === 'category';
-  }), [taxonomies]);
+    } = _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 = sprintf( // translators: %s: Name of the post type e.g: "Post".
+    __('Single item: %s'), labels.singular_name);
+
+    if (_needsUniqueIdentifier) {
+      menuItemTitle = sprintf( // translators: %1s: Name of the post type e.g: "Post"; %2s: Slug of the post type e.g: "book".
+      __('Single item: %1$s (%2$s)'), labels.singular_name, slug);
+    }
+
+    const menuItem = defaultTemplateType ? { ...defaultTemplateType
+    } : {
+      slug: generalTemplateSlug,
+      title: menuItemTitle,
+      description: sprintf( // translators: %s: Name of the post type e.g: "Post".
+      __('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) : post
+    };
+    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 = 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".
+              __('%1$s: %2$s'), labels.singular_name, suggestion.name);
+              const description = sprintf( // translators: Represents the description of a user's custom template in the Site Editor, e.g. "Template for Page: Hello"
+              __('Template for %1$s'), title);
+
+              if (_needsUniqueIdentifier) {
+                title = 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)"
+                __('%1$s %2$s'), title, `(${slug})`);
+              }
+
+              return {
+                title,
+                description,
+                slug: `${templatePrefixes[slug]}-${suggestion.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 = 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;
 };
-export const useTaxonomyTag = () => {
-  const taxonomies = usePublicTaxonomies();
-  return useMemo(() => taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.filter(_ref9 => {
+export const useTaxonomiesMenuItems = onClickMenuItem => {
+  const publicTaxonomies = usePublicTaxonomies();
+  const existingTemplates = useExistingTemplates();
+  const defaultTemplateTypes = useDefaultTemplateTypes(); // `category` and `post_tag` are special cases in template hierarchy.
+
+  const templatePrefixes = 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;
-    return slug === 'post_tag';
-  }), [taxonomies]);
+    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 = sprintf( // translators: %1s: Name of the taxonomy e.g: "Category"; %2s: Slug of the taxonomy e.g: "product_cat".
+      __('%1$s (%2$s)'), labels.singular_name, slug);
+    }
+
+    const menuItem = defaultTemplateType ? { ...defaultTemplateType
+    } : {
+      slug: generalTemplateSlug,
+      title: menuItemTitle,
+      description: sprintf( // translators: %s: Name of the taxonomy e.g: "Product Categories".
+      __('Displays taxonomy: %s.'), labels.singular_name),
+      icon: blockMeta
+    };
+    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 = 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".
+              __('%1$s: %2$s'), labels.singular_name, suggestion.name);
+              const description = sprintf( // translators: Represents the description of a user's custom template in the Site Editor, e.g. "Template for Category: shoes"
+              __('Template for %1$s'), title);
+
+              if (_needsUniqueIdentifier) {
+                title = 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)"
+                __('%1$s %2$s'), title, `(${slug})`);
+              }
+
+              return {
+                title,
+                description,
+                slug: `${templatePrefixes[slug]}-${suggestion.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 = 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;
 };
 /**
- * Helper hook that returns information about an entity having
- * records 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.
  *
- * For example we can search for `terms` in `taxonomy` entity or
- * `posts` in `postType` entity.
+ * Example:
+ * `existingTemplates` is: [ { slug: tag-apple }, { slug: page-about }, { slug: tag } ]
+ * `templatePrefixes` is: { post_tag: 'tag' }
+ * It will return: { post_tag: [apple] }
  *
- * First we need to find the existing records with an associated template,
- * to query afterwards for any remaing record, by excluding them.
+ * Note: We append the `-` to the given template prefix in this function for our checks.
  *
- * @param {string[]}     existingTemplates The existing templates.
- * @param {Object[]}     entities          The array of entities we need to get extra information.
- * @param {EntityConfig} entityConfig      The entity config.
- * @return {Record<string,EntitiesInfo>} An object with the `entities.slug` as `keys` and EntitiesInfo as values.
+ * @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.
  */
 
-const useEntitiesInfo = (existingTemplates, entities, _ref10) => {
-  let {
-    entityName,
-    templatePrefix,
-    templateSlug
-  } = _ref10;
-  const slugsToExcludePerEntity = useMemo(() => {
-    return entities === null || entities === void 0 ? void 0 : entities.reduce((accumulator, entity) => {
-      let _prefix = `${templateSlug || entity.slug}-`;
-
-      if (templatePrefix) {
-        _prefix = templatePrefix + _prefix;
-      }
-
+const useExistingTemplateSlugs = templatePrefixes => {
+  const existingTemplates = useExistingTemplates();
+  const existingSlugs = useMemo(() => {
+    return Object.entries(templatePrefixes || {}).reduce((accumulator, _ref13) => {
+      let [slug, prefix] = _ref13;
       const slugsWithTemplates = (existingTemplates || []).reduce((_accumulator, existingTemplate) => {
+        const _prefix = `${prefix}-`;
+
         if (existingTemplate.slug.startsWith(_prefix)) {
           _accumulator.push(existingTemplate.slug.substring(_prefix.length));
         }
@@ -245,43 +420,70 @@ const useEntitiesInfo = (existingTemplates, entities, _ref10) => {
       }, []);
 
       if (slugsWithTemplates.length) {
-        accumulator[entity.slug] = slugsWithTemplates;
+        accumulator[slug] = slugsWithTemplates;
       }
 
       return accumulator;
     }, {});
-  }, [entities, existingTemplates]);
-  const recordsToExcludePerEntity = 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.
+ * @return {Record<string,EntitiesInfo>} An object with the entity's slug as key and the existing records as value.
+ */
+
 
-    return Object.entries(slugsToExcludePerEntity).reduce((accumulator, _ref11) => {
-      let [slug, slugsWithTemplates] = _ref11;
-      const postsWithTemplates = select(coreStore).getEntityRecords(entityName, slug, {
+const useTemplatesToExclude = (entityName, templatePrefixes) => {
+  const slugsToExcludePerEntity = useExistingTemplateSlugs(templatePrefixes);
+  const recordsToExcludePerEntity = useSelect(select => {
+    return Object.entries(slugsToExcludePerEntity || {}).reduce((accumulator, _ref14) => {
+      let [slug, slugsWithTemplates] = _ref14;
+      const entitiesWithTemplates = select(coreStore).getEntityRecords(entityName, slug, {
         _fields: 'id',
         context: 'view',
         slug: slugsWithTemplates
       });
 
-      if (postsWithTemplates !== null && postsWithTemplates !== void 0 && postsWithTemplates.length) {
-        accumulator[slug] = postsWithTemplates;
+      if (entitiesWithTemplates !== null && entitiesWithTemplates !== void 0 && entitiesWithTemplates.length) {
+        accumulator[slug] = entitiesWithTemplates;
       }
 
       return accumulator;
     }, {});
   }, [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.
+ * @return {Record<string,EntitiesInfo>} An object with the entity's slug as key and the EntitiesInfo as value.
+ */
+
+
+const useEntitiesInfo = (entityName, templatePrefixes) => {
+  const recordsToExcludePerEntity = useTemplatesToExclude(entityName, templatePrefixes);
   const entitiesInfo = useSelect(select => {
-    return entities === null || entities === void 0 ? void 0 : entities.reduce((accumulator, _ref12) => {
+    return Object.keys(templatePrefixes || {}).reduce((accumulator, slug) => {
       var _recordsToExcludePerE, _select$getEntityReco;
 
-      let {
-        slug
-      } = _ref12;
-      const existingEntitiesIds = (recordsToExcludePerEntity === null || recordsToExcludePerEntity === void 0 ? void 0 : (_recordsToExcludePerE = recordsToExcludePerEntity[slug]) === null || _recordsToExcludePerE === void 0 ? void 0 : _recordsToExcludePerE.map(_ref13 => {
+      const existingEntitiesIds = (recordsToExcludePerEntity === null || recordsToExcludePerEntity === void 0 ? void 0 : (_recordsToExcludePerE = recordsToExcludePerEntity[slug]) === null || _recordsToExcludePerE === void 0 ? void 0 : _recordsToExcludePerE.map(_ref15 => {
         let {
           id
-        } = _ref13;
+        } = _ref15;
         return id;
       })) || [];
       accumulator[slug] = {
@@ -295,71 +497,7 @@ const useEntitiesInfo = (existingTemplates, entities, _ref10) => {
       };
       return accumulator;
     }, {});
-  }, [entities, recordsToExcludePerEntity]);
+  }, [templatePrefixes, recordsToExcludePerEntity]);
   return entitiesInfo;
 };
-
-export const useExtraTemplates = (entities, entityConfig, onClickMenuItem) => {
-  const existingTemplates = useExistingTemplates();
-  const defaultTemplateTypes = useDefaultTemplateTypes();
-  const entitiesInfo = useEntitiesInfo(existingTemplates, entities, entityConfig);
-  const existingTemplateSlugs = (existingTemplates || []).map(_ref14 => {
-    let {
-      slug
-    } = _ref14;
-    return slug;
-  });
-  const extraTemplates = (entities || []).reduce((accumulator, entity) => {
-    var _entityConfig$getIcon, _entitiesInfo$slug;
-
-    const {
-      slug,
-      labels,
-      icon
-    } = entity;
-    const slugForGeneralTemplate = entityConfig.templateSlug || slug; // 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 defaultTemplateType = defaultTemplateTypes === null || defaultTemplateTypes === void 0 ? void 0 : defaultTemplateTypes.find(_ref15 => {
-      let {
-        slug: _slug
-      } = _ref15;
-      return _slug === slugForGeneralTemplate;
-    });
-    const generalTemplateSlug = (defaultTemplateType === null || defaultTemplateType === void 0 ? void 0 : defaultTemplateType.slug) || `${entityConfig.templatePrefix}${slug}`;
-    const hasGeneralTemplate = existingTemplateSlugs === null || existingTemplateSlugs === void 0 ? void 0 : existingTemplateSlugs.includes(generalTemplateSlug);
-    const menuItem = defaultTemplateType ? { ...defaultTemplateType
-    } : {
-      slug: generalTemplateSlug,
-      title: entityConfig.getTitle(labels),
-      description: entityConfig.getDescription(labels),
-      icon: (_entityConfig$getIcon = entityConfig.getIcon) === null || _entityConfig$getIcon === void 0 ? void 0 : _entityConfig$getIcon.call(entityConfig, icon)
-    };
-    const hasEntities = entitiesInfo === null || entitiesInfo === void 0 ? void 0 : (_entitiesInfo$slug = entitiesInfo[slug]) === null || _entitiesInfo$slug === void 0 ? void 0 : _entitiesInfo$slug.hasEntities; // We have a different template creation flow only if they have entities.
-
-    if (hasEntities) {
-      menuItem.onClick = template => {
-        onClickMenuItem({
-          type: entityConfig.entityName,
-          slug,
-          config: entityConfig,
-          labels,
-          hasGeneralTemplate,
-          template,
-          postsToExclude: entitiesInfo[slug].existingEntitiesIds
-        });
-      };
-    } // 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;
-  }, []);
-  return extraTemplates;
-};
 //# sourceMappingURL=utils.js.map