@wordpress/core-data/build-module/private-selectors.js

Access to and manipulation of core WordPress entities.

// packages/core-data/src/private-selectors.ts
import { createSelector, createRegistrySelector } from "@wordpress/data";
import { getDefaultTemplateId, getEntityRecord } from "./selectors";
import { STORE_NAME } from "./name";
import { unlock } from "./lock-unlock";
import { getSyncManager } from "./sync";
import logEntityDeprecation from "./utils/log-entity-deprecation";
function getUndoManager(state) {
  if (window.__experimentalEnableSync) {
    if (globalThis.IS_GUTENBERG_PLUGIN) {
      return getSyncManager()?.undoManager ?? state.undoManager;
    }
  }
  return state.undoManager;
}
function getNavigationFallbackId(state) {
  return state.navigationFallbackId;
}
var getBlockPatternsForPostType = createRegistrySelector(
  (select) => createSelector(
    (state, postType) => select(STORE_NAME).getBlockPatterns().filter(
      ({ postTypes }) => !postTypes || Array.isArray(postTypes) && postTypes.includes(postType)
    ),
    () => [select(STORE_NAME).getBlockPatterns()]
  )
);
var getEntityRecordsPermissions = createRegistrySelector(
  (select) => createSelector(
    (state, kind, name, ids) => {
      const normalizedIds = Array.isArray(ids) ? ids : [ids];
      return normalizedIds.map((id) => ({
        delete: select(STORE_NAME).canUser("delete", {
          kind,
          name,
          id
        }),
        update: select(STORE_NAME).canUser("update", {
          kind,
          name,
          id
        })
      }));
    },
    (state) => [state.userPermissions]
  )
);
function getEntityRecordPermissions(state, kind, name, id) {
  logEntityDeprecation(kind, name, "getEntityRecordPermissions");
  return getEntityRecordsPermissions(state, kind, name, id)[0];
}
function getRegisteredPostMeta(state, postType) {
  return state.registeredPostMeta?.[postType] ?? {};
}
function normalizePageId(value) {
  if (!value || !["number", "string"].includes(typeof value)) {
    return null;
  }
  if (Number(value) === 0) {
    return null;
  }
  return value.toString();
}
var getHomePage = createRegistrySelector(
  (select) => createSelector(
    () => {
      const siteData = select(STORE_NAME).getEntityRecord(
        "root",
        "__unstableBase"
      );
      if (!siteData) {
        return null;
      }
      const homepageId = siteData?.show_on_front === "page" ? normalizePageId(siteData.page_on_front) : null;
      if (homepageId) {
        return { postType: "page", postId: homepageId };
      }
      const frontPageTemplateId = select(
        STORE_NAME
      ).getDefaultTemplateId({
        slug: "front-page"
      });
      if (!frontPageTemplateId) {
        return null;
      }
      return { postType: "wp_template", postId: frontPageTemplateId };
    },
    (state) => [
      // Even though getDefaultTemplateId.shouldInvalidate returns true when root/site changes,
      // it doesn't seem to invalidate this cache, I'm not sure why.
      getEntityRecord(state, "root", "site"),
      getEntityRecord(state, "root", "__unstableBase"),
      getDefaultTemplateId(state, {
        slug: "front-page"
      })
    ]
  )
);
var getPostsPageId = createRegistrySelector((select) => () => {
  const siteData = select(STORE_NAME).getEntityRecord(
    "root",
    "__unstableBase"
  );
  return siteData?.show_on_front === "page" ? normalizePageId(siteData.page_for_posts) : null;
});
var getTemplateId = createRegistrySelector(
  (select) => (state, postType, postId) => {
    const homepage = unlock(select(STORE_NAME)).getHomePage();
    if (!homepage) {
      return;
    }
    if (postType === "page" && postType === homepage?.postType && postId.toString() === homepage?.postId) {
      const templates = select(STORE_NAME).getEntityRecords(
        "postType",
        "wp_template",
        {
          per_page: -1
        }
      );
      if (!templates) {
        return;
      }
      const id = templates.find(({ slug }) => slug === "front-page")?.id;
      if (id) {
        return id;
      }
    }
    const editedEntity = select(STORE_NAME).getEditedEntityRecord(
      "postType",
      postType,
      postId
    );
    if (!editedEntity) {
      return;
    }
    const postsPageId = unlock(select(STORE_NAME)).getPostsPageId();
    if (postType === "page" && postsPageId === postId.toString()) {
      return select(STORE_NAME).getDefaultTemplateId({
        slug: "home"
      });
    }
    const currentTemplateSlug = editedEntity.template;
    if (currentTemplateSlug) {
      const currentTemplate = select(STORE_NAME).getEntityRecords("postType", "wp_template", {
        per_page: -1
      })?.find(({ slug }) => slug === currentTemplateSlug);
      if (currentTemplate) {
        return currentTemplate.id;
      }
    }
    let slugToCheck;
    if (editedEntity.slug) {
      slugToCheck = postType === "page" ? `${postType}-${editedEntity.slug}` : `single-${postType}-${editedEntity.slug}`;
    } else {
      slugToCheck = postType === "page" ? "page" : `single-${postType}`;
    }
    return select(STORE_NAME).getDefaultTemplateId({
      slug: slugToCheck
    });
  }
);
function getEditorSettings(state) {
  return state.editorSettings;
}
function getEditorAssets(state) {
  return state.editorAssets;
}
export {
  getBlockPatternsForPostType,
  getEditorAssets,
  getEditorSettings,
  getEntityRecordPermissions,
  getEntityRecordsPermissions,
  getHomePage,
  getNavigationFallbackId,
  getPostsPageId,
  getRegisteredPostMeta,
  getTemplateId,
  getUndoManager
};
//# sourceMappingURL=private-selectors.js.map