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

Access to and manipulation of core WordPress entities.

// packages/core-data/src/selectors.ts
import { createSelector, createRegistrySelector } from "@wordpress/data";
import { addQueryArgs } from "@wordpress/url";
import deprecated from "@wordpress/deprecated";
import { STORE_NAME } from "./name";
import {
  getQueriedItems,
  getQueriedTotalItems,
  getQueriedTotalPages
} from "./queried-data";
import { DEFAULT_ENTITY_KEY } from "./entities";
import { getUndoManager } from "./private-selectors";
import {
  getNormalizedCommaSeparable,
  isRawAttribute,
  setNestedValue,
  isNumericID,
  getUserPermissionCacheKey
} from "./utils";
import logEntityDeprecation from "./utils/log-entity-deprecation";
var EMPTY_OBJECT = {};
var isRequestingEmbedPreview = createRegistrySelector(
  (select) => (state, url) => {
    return select(STORE_NAME).isResolving("getEmbedPreview", [
      url
    ]);
  }
);
function getAuthors(state, query) {
  deprecated("select( 'core' ).getAuthors()", {
    since: "5.9",
    alternative: "select( 'core' ).getUsers({ who: 'authors' })"
  });
  const path = addQueryArgs(
    "/wp/v2/users/?who=authors&per_page=100",
    query
  );
  return getUserQueryResults(state, path);
}
function getCurrentUser(state) {
  return state.currentUser;
}
var getUserQueryResults = createSelector(
  (state, queryID) => {
    const queryResults = state.users.queries[queryID] ?? [];
    return queryResults.map((id) => state.users.byId[id]);
  },
  (state, queryID) => [
    state.users.queries[queryID],
    state.users.byId
  ]
);
function getEntitiesByKind(state, kind) {
  deprecated("wp.data.select( 'core' ).getEntitiesByKind()", {
    since: "6.0",
    alternative: "wp.data.select( 'core' ).getEntitiesConfig()"
  });
  return getEntitiesConfig(state, kind);
}
var getEntitiesConfig = createSelector(
  (state, kind) => state.entities.config.filter((entity) => entity.kind === kind),
  /* eslint-disable @typescript-eslint/no-unused-vars */
  (state, kind) => state.entities.config
  /* eslint-enable @typescript-eslint/no-unused-vars */
);
function getEntity(state, kind, name) {
  deprecated("wp.data.select( 'core' ).getEntity()", {
    since: "6.0",
    alternative: "wp.data.select( 'core' ).getEntityConfig()"
  });
  return getEntityConfig(state, kind, name);
}
function getEntityConfig(state, kind, name) {
  logEntityDeprecation(kind, name, "getEntityConfig");
  return state.entities.config?.find(
    (config) => config.kind === kind && config.name === name
  );
}
var getEntityRecord = createSelector(
  ((state, kind, name, key, query) => {
    logEntityDeprecation(kind, name, "getEntityRecord");
    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
    if (!queriedState) {
      return void 0;
    }
    const context = query?.context ?? "default";
    if (!query || !query._fields) {
      if (!queriedState.itemIsComplete[context]?.[key]) {
        return void 0;
      }
      return queriedState.items[context][key];
    }
    const item = queriedState.items[context]?.[key];
    if (!item) {
      return item;
    }
    const filteredItem = {};
    const fields = getNormalizedCommaSeparable(query._fields) ?? [];
    for (let f = 0; f < fields.length; f++) {
      const field = fields[f].split(".");
      let value = item;
      field.forEach((fieldName) => {
        value = value?.[fieldName];
      });
      setNestedValue(filteredItem, field, value);
    }
    return filteredItem;
  }),
  (state, kind, name, recordId, query) => {
    const context = query?.context ?? "default";
    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
    return [
      queriedState?.items[context]?.[recordId],
      queriedState?.itemIsComplete[context]?.[recordId]
    ];
  }
);
getEntityRecord.__unstableNormalizeArgs = (args) => {
  const newArgs = [...args];
  const recordKey = newArgs?.[2];
  newArgs[2] = isNumericID(recordKey) ? Number(recordKey) : recordKey;
  return newArgs;
};
function hasEntityRecord(state, kind, name, key, query) {
  const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
  if (!queriedState) {
    return false;
  }
  const context = query?.context ?? "default";
  if (!query || !query._fields) {
    return !!queriedState.itemIsComplete[context]?.[key];
  }
  const item = queriedState.items[context]?.[key];
  if (!item) {
    return false;
  }
  const fields = getNormalizedCommaSeparable(query._fields) ?? [];
  for (let i = 0; i < fields.length; i++) {
    const path = fields[i].split(".");
    let value = item;
    for (let p = 0; p < path.length; p++) {
      const part = path[p];
      if (!value || !Object.hasOwn(value, part)) {
        return false;
      }
      value = value[part];
    }
  }
  return true;
}
function __experimentalGetEntityRecordNoResolver(state, kind, name, key) {
  return getEntityRecord(state, kind, name, key);
}
var getRawEntityRecord = createSelector(
  (state, kind, name, key) => {
    logEntityDeprecation(kind, name, "getRawEntityRecord");
    const record = getEntityRecord(
      state,
      kind,
      name,
      key
    );
    return record && Object.keys(record).reduce((accumulator, _key) => {
      if (isRawAttribute(getEntityConfig(state, kind, name), _key)) {
        accumulator[_key] = record[_key]?.raw !== void 0 ? record[_key]?.raw : record[_key];
      } else {
        accumulator[_key] = record[_key];
      }
      return accumulator;
    }, {});
  },
  (state, kind, name, recordId, query) => {
    const context = query?.context ?? "default";
    return [
      state.entities.config,
      state.entities.records?.[kind]?.[name]?.queriedData?.items[context]?.[recordId],
      state.entities.records?.[kind]?.[name]?.queriedData?.itemIsComplete[context]?.[recordId]
    ];
  }
);
function hasEntityRecords(state, kind, name, query) {
  logEntityDeprecation(kind, name, "hasEntityRecords");
  return Array.isArray(getEntityRecords(state, kind, name, query));
}
var getEntityRecords = ((state, kind, name, query) => {
  logEntityDeprecation(kind, name, "getEntityRecords");
  const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
  if (!queriedState) {
    return null;
  }
  return getQueriedItems(queriedState, query);
});
var getEntityRecordsTotalItems = (state, kind, name, query) => {
  logEntityDeprecation(kind, name, "getEntityRecordsTotalItems");
  const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
  if (!queriedState) {
    return null;
  }
  return getQueriedTotalItems(queriedState, query);
};
var getEntityRecordsTotalPages = (state, kind, name, query) => {
  logEntityDeprecation(kind, name, "getEntityRecordsTotalPages");
  const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
  if (!queriedState) {
    return null;
  }
  if (query?.per_page === -1) {
    return 1;
  }
  const totalItems = getQueriedTotalItems(queriedState, query);
  if (!totalItems) {
    return totalItems;
  }
  if (!query?.per_page) {
    return getQueriedTotalPages(queriedState, query);
  }
  return Math.ceil(totalItems / query.per_page);
};
var __experimentalGetDirtyEntityRecords = createSelector(
  (state) => {
    const {
      entities: { records }
    } = state;
    const dirtyRecords = [];
    Object.keys(records).forEach((kind) => {
      Object.keys(records[kind]).forEach((name) => {
        const primaryKeys = Object.keys(records[kind][name].edits).filter(
          (primaryKey) => (
            // The entity record must exist (not be deleted),
            // and it must have edits.
            getEntityRecord(state, kind, name, primaryKey) && hasEditsForEntityRecord(state, kind, name, primaryKey)
          )
        );
        if (primaryKeys.length) {
          const entityConfig = getEntityConfig(state, kind, name);
          primaryKeys.forEach((primaryKey) => {
            const entityRecord = getEditedEntityRecord(
              state,
              kind,
              name,
              primaryKey
            );
            dirtyRecords.push({
              // We avoid using primaryKey because it's transformed into a string
              // when it's used as an object key.
              key: entityRecord ? entityRecord[entityConfig.key || DEFAULT_ENTITY_KEY] : void 0,
              title: entityConfig?.getTitle?.(entityRecord) || "",
              name,
              kind
            });
          });
        }
      });
    });
    return dirtyRecords;
  },
  (state) => [state.entities.records]
);
var __experimentalGetEntitiesBeingSaved = createSelector(
  (state) => {
    const {
      entities: { records }
    } = state;
    const recordsBeingSaved = [];
    Object.keys(records).forEach((kind) => {
      Object.keys(records[kind]).forEach((name) => {
        const primaryKeys = Object.keys(records[kind][name].saving).filter(
          (primaryKey) => isSavingEntityRecord(state, kind, name, primaryKey)
        );
        if (primaryKeys.length) {
          const entityConfig = getEntityConfig(state, kind, name);
          primaryKeys.forEach((primaryKey) => {
            const entityRecord = getEditedEntityRecord(
              state,
              kind,
              name,
              primaryKey
            );
            recordsBeingSaved.push({
              // We avoid using primaryKey because it's transformed into a string
              // when it's used as an object key.
              key: entityRecord ? entityRecord[entityConfig.key || DEFAULT_ENTITY_KEY] : void 0,
              title: entityConfig?.getTitle?.(entityRecord) || "",
              name,
              kind
            });
          });
        }
      });
    });
    return recordsBeingSaved;
  },
  (state) => [state.entities.records]
);
function getEntityRecordEdits(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "getEntityRecordEdits");
  return state.entities.records?.[kind]?.[name]?.edits?.[recordId];
}
var getEntityRecordNonTransientEdits = createSelector(
  (state, kind, name, recordId) => {
    logEntityDeprecation(kind, name, "getEntityRecordNonTransientEdits");
    const { transientEdits } = getEntityConfig(state, kind, name) || {};
    const edits = getEntityRecordEdits(state, kind, name, recordId) || {};
    if (!transientEdits) {
      return edits;
    }
    return Object.keys(edits).reduce((acc, key) => {
      if (!transientEdits[key]) {
        acc[key] = edits[key];
      }
      return acc;
    }, {});
  },
  (state, kind, name, recordId) => [
    state.entities.config,
    state.entities.records?.[kind]?.[name]?.edits?.[recordId]
  ]
);
function hasEditsForEntityRecord(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "hasEditsForEntityRecord");
  return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(
    getEntityRecordNonTransientEdits(state, kind, name, recordId)
  ).length > 0;
}
var getEditedEntityRecord = createSelector(
  (state, kind, name, recordId) => {
    logEntityDeprecation(kind, name, "getEditedEntityRecord");
    const raw = getRawEntityRecord(state, kind, name, recordId);
    const edited = getEntityRecordEdits(state, kind, name, recordId);
    if (!raw && !edited) {
      return false;
    }
    return {
      ...raw,
      ...edited
    };
  },
  (state, kind, name, recordId, query) => {
    const context = query?.context ?? "default";
    return [
      state.entities.config,
      state.entities.records?.[kind]?.[name]?.queriedData.items[context]?.[recordId],
      state.entities.records?.[kind]?.[name]?.queriedData.itemIsComplete[context]?.[recordId],
      state.entities.records?.[kind]?.[name]?.edits?.[recordId]
    ];
  }
);
function isAutosavingEntityRecord(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "isAutosavingEntityRecord");
  const { pending, isAutosave } = state.entities.records?.[kind]?.[name]?.saving?.[recordId] ?? {};
  return Boolean(pending && isAutosave);
}
function isSavingEntityRecord(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "isSavingEntityRecord");
  return state.entities.records?.[kind]?.[name]?.saving?.[recordId]?.pending ?? false;
}
function isDeletingEntityRecord(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "isDeletingEntityRecord");
  return state.entities.records?.[kind]?.[name]?.deleting?.[recordId]?.pending ?? false;
}
function getLastEntitySaveError(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "getLastEntitySaveError");
  return state.entities.records?.[kind]?.[name]?.saving?.[recordId]?.error;
}
function getLastEntityDeleteError(state, kind, name, recordId) {
  logEntityDeprecation(kind, name, "getLastEntityDeleteError");
  return state.entities.records?.[kind]?.[name]?.deleting?.[recordId]?.error;
}
function getUndoEdit(state) {
  deprecated("select( 'core' ).getUndoEdit()", {
    since: "6.3"
  });
  return void 0;
}
function getRedoEdit(state) {
  deprecated("select( 'core' ).getRedoEdit()", {
    since: "6.3"
  });
  return void 0;
}
function hasUndo(state) {
  return getUndoManager(state).hasUndo();
}
function hasRedo(state) {
  return getUndoManager(state).hasRedo();
}
function getCurrentTheme(state) {
  if (!state.currentTheme) {
    return null;
  }
  return getEntityRecord(state, "root", "theme", state.currentTheme);
}
function __experimentalGetCurrentGlobalStylesId(state) {
  return state.currentGlobalStylesId;
}
function getThemeSupports(state) {
  return getCurrentTheme(state)?.theme_supports ?? EMPTY_OBJECT;
}
function getEmbedPreview(state, url) {
  return state.embedPreviews[url];
}
function isPreviewEmbedFallback(state, url) {
  const preview = state.embedPreviews[url];
  const oEmbedLinkCheck = '<a href="' + url + '">' + url + "</a>";
  if (!preview) {
    return false;
  }
  return preview.html === oEmbedLinkCheck;
}
function canUser(state, action, resource, id) {
  const isEntity = typeof resource === "object";
  if (isEntity && (!resource.kind || !resource.name)) {
    return false;
  }
  if (isEntity) {
    logEntityDeprecation(resource.kind, resource.name, "canUser");
  }
  const key = getUserPermissionCacheKey(action, resource, id);
  return state.userPermissions[key];
}
function canUserEditEntityRecord(state, kind, name, recordId) {
  deprecated(`wp.data.select( 'core' ).canUserEditEntityRecord()`, {
    since: "6.7",
    alternative: `wp.data.select( 'core' ).canUser( 'update', { kind, name, id } )`
  });
  return canUser(state, "update", { kind, name, id: recordId });
}
function getAutosaves(state, postType, postId) {
  return state.autosaves[postId];
}
function getAutosave(state, postType, postId, authorId) {
  if (authorId === void 0) {
    return;
  }
  const autosaves = state.autosaves[postId];
  return autosaves?.find(
    (autosave) => autosave.author === authorId
  );
}
var hasFetchedAutosaves = createRegistrySelector(
  (select) => (state, postType, postId) => {
    return select(STORE_NAME).hasFinishedResolution("getAutosaves", [
      postType,
      postId
    ]);
  }
);
function getReferenceByDistinctEdits(state) {
  return state.editsReference;
}
function __experimentalGetCurrentThemeBaseGlobalStyles(state) {
  const currentTheme = getCurrentTheme(state);
  if (!currentTheme) {
    return null;
  }
  return state.themeBaseGlobalStyles[currentTheme.stylesheet];
}
function __experimentalGetCurrentThemeGlobalStylesVariations(state) {
  const currentTheme = getCurrentTheme(state);
  if (!currentTheme) {
    return null;
  }
  return state.themeGlobalStyleVariations[currentTheme.stylesheet];
}
function getBlockPatterns(state) {
  return state.blockPatterns;
}
function getBlockPatternCategories(state) {
  return state.blockPatternCategories;
}
function getUserPatternCategories(state) {
  return state.userPatternCategories;
}
function getCurrentThemeGlobalStylesRevisions(state) {
  deprecated("select( 'core' ).getCurrentThemeGlobalStylesRevisions()", {
    since: "6.5.0",
    alternative: "select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )"
  });
  const currentGlobalStylesId = __experimentalGetCurrentGlobalStylesId(state);
  if (!currentGlobalStylesId) {
    return null;
  }
  return state.themeGlobalStyleRevisions[currentGlobalStylesId];
}
function getDefaultTemplateId(state, query) {
  return state.defaultTemplates[JSON.stringify(query)];
}
var getRevisions = (state, kind, name, recordKey, query) => {
  logEntityDeprecation(kind, name, "getRevisions");
  const queriedStateRevisions = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
  if (!queriedStateRevisions) {
    return null;
  }
  return getQueriedItems(queriedStateRevisions, query);
};
var getRevision = createSelector(
  (state, kind, name, recordKey, revisionKey, query) => {
    logEntityDeprecation(kind, name, "getRevision");
    const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
    if (!queriedState) {
      return void 0;
    }
    const context = query?.context ?? "default";
    if (!query || !query._fields) {
      if (!queriedState.itemIsComplete[context]?.[revisionKey]) {
        return void 0;
      }
      return queriedState.items[context][revisionKey];
    }
    const item = queriedState.items[context]?.[revisionKey];
    if (!item) {
      return item;
    }
    const filteredItem = {};
    const fields = getNormalizedCommaSeparable(query._fields) ?? [];
    for (let f = 0; f < fields.length; f++) {
      const field = fields[f].split(".");
      let value = item;
      field.forEach((fieldName) => {
        value = value?.[fieldName];
      });
      setNestedValue(filteredItem, field, value);
    }
    return filteredItem;
  },
  (state, kind, name, recordKey, revisionKey, query) => {
    const context = query?.context ?? "default";
    const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
    return [
      queriedState?.items?.[context]?.[revisionKey],
      queriedState?.itemIsComplete?.[context]?.[revisionKey]
    ];
  }
);
export {
  __experimentalGetCurrentGlobalStylesId,
  __experimentalGetCurrentThemeBaseGlobalStyles,
  __experimentalGetCurrentThemeGlobalStylesVariations,
  __experimentalGetDirtyEntityRecords,
  __experimentalGetEntitiesBeingSaved,
  __experimentalGetEntityRecordNoResolver,
  canUser,
  canUserEditEntityRecord,
  getAuthors,
  getAutosave,
  getAutosaves,
  getBlockPatternCategories,
  getBlockPatterns,
  getCurrentTheme,
  getCurrentThemeGlobalStylesRevisions,
  getCurrentUser,
  getDefaultTemplateId,
  getEditedEntityRecord,
  getEmbedPreview,
  getEntitiesByKind,
  getEntitiesConfig,
  getEntity,
  getEntityConfig,
  getEntityRecord,
  getEntityRecordEdits,
  getEntityRecordNonTransientEdits,
  getEntityRecords,
  getEntityRecordsTotalItems,
  getEntityRecordsTotalPages,
  getLastEntityDeleteError,
  getLastEntitySaveError,
  getRawEntityRecord,
  getRedoEdit,
  getReferenceByDistinctEdits,
  getRevision,
  getRevisions,
  getThemeSupports,
  getUndoEdit,
  getUserPatternCategories,
  getUserQueryResults,
  hasEditsForEntityRecord,
  hasEntityRecord,
  hasEntityRecords,
  hasFetchedAutosaves,
  hasRedo,
  hasUndo,
  isAutosavingEntityRecord,
  isDeletingEntityRecord,
  isPreviewEmbedFallback,
  isRequestingEmbedPreview,
  isSavingEntityRecord
};
//# sourceMappingURL=selectors.js.map