@wordpress/core-data
Version:
Access to and manipulation of core WordPress entities.
662 lines (660 loc) • 20.6 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// packages/core-data/src/actions.js
var actions_exports = {};
__export(actions_exports, {
__experimentalBatch: () => __experimentalBatch,
__experimentalReceiveCurrentGlobalStylesId: () => __experimentalReceiveCurrentGlobalStylesId,
__experimentalReceiveThemeBaseGlobalStyles: () => __experimentalReceiveThemeBaseGlobalStyles,
__experimentalReceiveThemeGlobalStyleVariations: () => __experimentalReceiveThemeGlobalStyleVariations,
__experimentalSaveSpecifiedEntityEdits: () => __experimentalSaveSpecifiedEntityEdits,
__unstableCreateUndoLevel: () => __unstableCreateUndoLevel,
addEntities: () => addEntities,
deleteEntityRecord: () => deleteEntityRecord,
editEntityRecord: () => editEntityRecord,
receiveAutosaves: () => receiveAutosaves,
receiveCurrentTheme: () => receiveCurrentTheme,
receiveCurrentUser: () => receiveCurrentUser,
receiveDefaultTemplateId: () => receiveDefaultTemplateId,
receiveEmbedPreview: () => receiveEmbedPreview,
receiveEntityRecords: () => receiveEntityRecords,
receiveNavigationFallbackId: () => receiveNavigationFallbackId,
receiveRevisions: () => receiveRevisions,
receiveThemeGlobalStyleRevisions: () => receiveThemeGlobalStyleRevisions,
receiveThemeSupports: () => receiveThemeSupports,
receiveUploadPermissions: () => receiveUploadPermissions,
receiveUserPermission: () => receiveUserPermission,
receiveUserPermissions: () => receiveUserPermissions,
receiveUserQuery: () => receiveUserQuery,
redo: () => redo,
saveEditedEntityRecord: () => saveEditedEntityRecord,
saveEntityRecord: () => saveEntityRecord,
undo: () => undo
});
module.exports = __toCommonJS(actions_exports);
var import_es6 = __toESM(require("fast-deep-equal/es6"));
var import_uuid = require("uuid");
var import_api_fetch = __toESM(require("@wordpress/api-fetch"));
var import_url = require("@wordpress/url");
var import_deprecated = __toESM(require("@wordpress/deprecated"));
var import_utils = require("./utils");
var import_queried_data = require("./queried-data");
var import_entities = require("./entities");
var import_batch = require("./batch");
var import_name = require("./name");
var import_sync = require("./sync");
var import_log_entity_deprecation = __toESM(require("./utils/log-entity-deprecation"));
function receiveUserQuery(queryID, users) {
return {
type: "RECEIVE_USER_QUERY",
users: Array.isArray(users) ? users : [users],
queryID
};
}
function receiveCurrentUser(currentUser) {
return {
type: "RECEIVE_CURRENT_USER",
currentUser
};
}
function addEntities(entities) {
return {
type: "ADD_ENTITIES",
entities
};
}
function receiveEntityRecords(kind, name, records, query = void 0, invalidateCache = false, edits = void 0, meta = void 0) {
if (kind === "postType") {
records = (Array.isArray(records) ? records : [records]).map(
(record) => record.status === "auto-draft" ? { ...record, title: "" } : record
);
}
let action;
if (query) {
action = (0, import_queried_data.receiveQueriedItems)(records, query, edits, meta);
} else {
action = (0, import_queried_data.receiveItems)(records, edits, meta);
}
return {
...action,
kind,
name,
invalidateCache
};
}
function receiveCurrentTheme(currentTheme) {
return {
type: "RECEIVE_CURRENT_THEME",
currentTheme
};
}
function __experimentalReceiveCurrentGlobalStylesId(currentGlobalStylesId) {
return {
type: "RECEIVE_CURRENT_GLOBAL_STYLES_ID",
id: currentGlobalStylesId
};
}
function __experimentalReceiveThemeBaseGlobalStyles(stylesheet, globalStyles) {
return {
type: "RECEIVE_THEME_GLOBAL_STYLES",
stylesheet,
globalStyles
};
}
function __experimentalReceiveThemeGlobalStyleVariations(stylesheet, variations) {
return {
type: "RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS",
stylesheet,
variations
};
}
function receiveThemeSupports() {
(0, import_deprecated.default)("wp.data.dispatch( 'core' ).receiveThemeSupports", {
since: "5.9"
});
return {
type: "DO_NOTHING"
};
}
function receiveThemeGlobalStyleRevisions(currentId, revisions) {
(0, import_deprecated.default)(
"wp.data.dispatch( 'core' ).receiveThemeGlobalStyleRevisions()",
{
since: "6.5.0",
alternative: "wp.data.dispatch( 'core' ).receiveRevisions"
}
);
return {
type: "RECEIVE_THEME_GLOBAL_STYLE_REVISIONS",
currentId,
revisions
};
}
function receiveEmbedPreview(url, preview) {
return {
type: "RECEIVE_EMBED_PREVIEW",
url,
preview
};
}
var deleteEntityRecord = (kind, name, recordId, query, { __unstableFetch = import_api_fetch.default, throwOnError = false } = {}) => async ({ dispatch, resolveSelect }) => {
(0, import_log_entity_deprecation.default)(kind, name, "deleteEntityRecord");
const configs = await resolveSelect.getEntitiesConfig(kind);
const entityConfig = configs.find(
(config) => config.kind === kind && config.name === name
);
let error;
let deletedRecord = false;
if (!entityConfig) {
return;
}
const lock = await dispatch.__unstableAcquireStoreLock(
import_name.STORE_NAME,
["entities", "records", kind, name, recordId],
{ exclusive: true }
);
try {
dispatch({
type: "DELETE_ENTITY_RECORD_START",
kind,
name,
recordId
});
let hasError = false;
let { baseURL } = entityConfig;
if (kind === "postType" && name === "wp_template" && (recordId && typeof recordId === "string" && !/^\d+$/.test(recordId) || !window?.__experimentalTemplateActivate)) {
baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
}
try {
let path = `${baseURL}/${recordId}`;
if (query) {
path = (0, import_url.addQueryArgs)(path, query);
}
deletedRecord = await __unstableFetch({
path,
method: "DELETE"
});
await dispatch((0, import_queried_data.removeItems)(kind, name, recordId, true));
} catch (_error) {
hasError = true;
error = _error;
}
dispatch({
type: "DELETE_ENTITY_RECORD_FINISH",
kind,
name,
recordId,
error
});
if (hasError && throwOnError) {
throw error;
}
return deletedRecord;
} finally {
dispatch.__unstableReleaseStoreLock(lock);
}
};
var editEntityRecord = (kind, name, recordId, edits, options = {}) => ({ select, dispatch }) => {
(0, import_log_entity_deprecation.default)(kind, name, "editEntityRecord");
const entityConfig = select.getEntityConfig(kind, name);
if (!entityConfig) {
throw new Error(
`The entity being edited (${kind}, ${name}) does not have a loaded config.`
);
}
const { mergedEdits = {} } = entityConfig;
const record = select.getRawEntityRecord(kind, name, recordId);
const editedRecord = select.getEditedEntityRecord(
kind,
name,
recordId
);
const edit = {
kind,
name,
recordId,
// Clear edits when they are equal to their persisted counterparts
// so that the property is not considered dirty.
edits: Object.keys(edits).reduce((acc, key) => {
const recordValue = record[key];
const editedRecordValue = editedRecord[key];
const value = mergedEdits[key] ? { ...editedRecordValue, ...edits[key] } : edits[key];
acc[key] = (0, import_es6.default)(recordValue, value) ? void 0 : value;
return acc;
}, {})
};
if (window.__experimentalEnableSync && entityConfig.syncConfig) {
if (globalThis.IS_GUTENBERG_PLUGIN) {
const objectType = `${kind}/${name}`;
const objectId = recordId;
(0, import_sync.getSyncManager)()?.update(
objectType,
objectId,
edit.edits,
import_sync.LOCAL_EDITOR_ORIGIN
);
}
}
if (!options.undoIgnore) {
select.getUndoManager().addRecord(
[
{
id: { kind, name, recordId },
changes: Object.keys(edits).reduce((acc, key) => {
acc[key] = {
from: editedRecord[key],
to: edits[key]
};
return acc;
}, {})
}
],
options.isCached
);
}
dispatch({
type: "EDIT_ENTITY_RECORD",
...edit
});
};
var undo = () => ({ select, dispatch }) => {
const undoRecord = select.getUndoManager().undo();
if (!undoRecord) {
return;
}
dispatch({
type: "UNDO",
record: undoRecord
});
};
var redo = () => ({ select, dispatch }) => {
const redoRecord = select.getUndoManager().redo();
if (!redoRecord) {
return;
}
dispatch({
type: "REDO",
record: redoRecord
});
};
var __unstableCreateUndoLevel = () => ({ select }) => {
select.getUndoManager().addRecord();
};
var saveEntityRecord = (kind, name, record, {
isAutosave = false,
__unstableFetch = import_api_fetch.default,
throwOnError = false
} = {}) => async ({ select, resolveSelect, dispatch }) => {
(0, import_log_entity_deprecation.default)(kind, name, "saveEntityRecord");
const configs = await resolveSelect.getEntitiesConfig(kind);
const entityConfig = configs.find(
(config) => config.kind === kind && config.name === name
);
if (!entityConfig) {
return;
}
const entityIdKey = entityConfig.key ?? import_entities.DEFAULT_ENTITY_KEY;
const recordId = record[entityIdKey];
const isNewRecord = !!entityIdKey && !recordId;
const lock = await dispatch.__unstableAcquireStoreLock(
import_name.STORE_NAME,
["entities", "records", kind, name, recordId || (0, import_uuid.v4)()],
{ exclusive: true }
);
try {
for (const [key, value] of Object.entries(record)) {
if (typeof value === "function") {
const evaluatedValue = value(
select.getEditedEntityRecord(kind, name, recordId)
);
dispatch.editEntityRecord(
kind,
name,
recordId,
{
[key]: evaluatedValue
},
{ undoIgnore: true }
);
record[key] = evaluatedValue;
}
}
dispatch({
type: "SAVE_ENTITY_RECORD_START",
kind,
name,
recordId,
isAutosave
});
let updatedRecord;
let error;
let hasError = false;
let { baseURL } = entityConfig;
if (kind === "postType" && name === "wp_template" && (recordId && typeof recordId === "string" && !/^\d+$/.test(recordId) || !window?.__experimentalTemplateActivate)) {
baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
}
try {
const path = `${baseURL}${recordId ? "/" + recordId : ""}`;
const persistedRecord = !isNewRecord ? select.getRawEntityRecord(kind, name, recordId) : {};
if (isAutosave) {
const currentUser = select.getCurrentUser();
const currentUserId = currentUser ? currentUser.id : void 0;
const autosavePost = await resolveSelect.getAutosave(
persistedRecord.type,
persistedRecord.id,
currentUserId
);
let data = {
...persistedRecord,
...autosavePost,
...record
};
data = Object.keys(data).reduce(
(acc, key) => {
if ([
"title",
"excerpt",
"content",
"meta"
].includes(key)) {
acc[key] = data[key];
}
return acc;
},
{
// Do not update the `status` if we have edited it when auto saving.
// It's very important to let the user explicitly save this change,
// because it can lead to unexpected results. An example would be to
// have a draft post and change the status to publish.
status: data.status === "auto-draft" ? "draft" : void 0
}
);
updatedRecord = await __unstableFetch({
path: `${path}/autosaves`,
method: "POST",
data
});
if (persistedRecord.id === updatedRecord.id) {
let newRecord = {
...persistedRecord,
...data,
...updatedRecord
};
newRecord = Object.keys(newRecord).reduce(
(acc, key) => {
if (["title", "excerpt", "content"].includes(
key
)) {
acc[key] = newRecord[key];
} else if (key === "status") {
acc[key] = persistedRecord.status === "auto-draft" && newRecord.status === "draft" ? newRecord.status : persistedRecord.status;
} else {
acc[key] = persistedRecord[key];
}
return acc;
},
{}
);
dispatch.receiveEntityRecords(
kind,
name,
newRecord,
void 0,
true
);
} else {
dispatch.receiveAutosaves(
persistedRecord.id,
updatedRecord
);
}
} else {
let edits = record;
if (entityConfig.__unstablePrePersist) {
edits = {
...edits,
...entityConfig.__unstablePrePersist(
persistedRecord,
edits
)
};
}
updatedRecord = await __unstableFetch({
path,
method: recordId ? "PUT" : "POST",
data: edits
});
dispatch.receiveEntityRecords(
kind,
name,
updatedRecord,
void 0,
true,
edits
);
}
} catch (_error) {
hasError = true;
error = _error;
}
dispatch({
type: "SAVE_ENTITY_RECORD_FINISH",
kind,
name,
recordId,
error,
isAutosave
});
if (hasError && throwOnError) {
throw error;
}
return updatedRecord;
} finally {
dispatch.__unstableReleaseStoreLock(lock);
}
};
var __experimentalBatch = (requests) => async ({ dispatch }) => {
const batch = (0, import_batch.createBatch)();
const api = {
saveEntityRecord(kind, name, record, options) {
return batch.add(
(add) => dispatch.saveEntityRecord(kind, name, record, {
...options,
__unstableFetch: add
})
);
},
saveEditedEntityRecord(kind, name, recordId, options) {
return batch.add(
(add) => dispatch.saveEditedEntityRecord(kind, name, recordId, {
...options,
__unstableFetch: add
})
);
},
deleteEntityRecord(kind, name, recordId, query, options) {
return batch.add(
(add) => dispatch.deleteEntityRecord(kind, name, recordId, query, {
...options,
__unstableFetch: add
})
);
}
};
const resultPromises = requests.map((request) => request(api));
const [, ...results] = await Promise.all([
batch.run(),
...resultPromises
]);
return results;
};
var saveEditedEntityRecord = (kind, name, recordId, options) => async ({ select, dispatch, resolveSelect }) => {
(0, import_log_entity_deprecation.default)(kind, name, "saveEditedEntityRecord");
if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
return;
}
const configs = await resolveSelect.getEntitiesConfig(kind);
const entityConfig = configs.find(
(config) => config.kind === kind && config.name === name
);
if (!entityConfig) {
return;
}
const entityIdKey = entityConfig.key || import_entities.DEFAULT_ENTITY_KEY;
const edits = select.getEntityRecordNonTransientEdits(
kind,
name,
recordId
);
const record = { [entityIdKey]: recordId, ...edits };
return await dispatch.saveEntityRecord(kind, name, record, options);
};
var __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({ select, dispatch, resolveSelect }) => {
(0, import_log_entity_deprecation.default)(
kind,
name,
"__experimentalSaveSpecifiedEntityEdits"
);
if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
return;
}
const edits = select.getEntityRecordNonTransientEdits(
kind,
name,
recordId
);
const editsToSave = {};
for (const item of itemsToSave) {
(0, import_utils.setNestedValue)(editsToSave, item, (0, import_utils.getNestedValue)(edits, item));
}
const configs = await resolveSelect.getEntitiesConfig(kind);
const entityConfig = configs.find(
(config) => config.kind === kind && config.name === name
);
const entityIdKey = entityConfig?.key || import_entities.DEFAULT_ENTITY_KEY;
if (recordId) {
editsToSave[entityIdKey] = recordId;
}
return await dispatch.saveEntityRecord(
kind,
name,
editsToSave,
options
);
};
function receiveUploadPermissions(hasUploadPermissions) {
(0, import_deprecated.default)("wp.data.dispatch( 'core' ).receiveUploadPermissions", {
since: "5.9",
alternative: "receiveUserPermission"
});
return receiveUserPermission("create/media", hasUploadPermissions);
}
function receiveUserPermission(key, isAllowed) {
return {
type: "RECEIVE_USER_PERMISSION",
key,
isAllowed
};
}
function receiveUserPermissions(permissions) {
return {
type: "RECEIVE_USER_PERMISSIONS",
permissions
};
}
function receiveAutosaves(postId, autosaves) {
return {
type: "RECEIVE_AUTOSAVES",
postId,
autosaves: Array.isArray(autosaves) ? autosaves : [autosaves]
};
}
function receiveNavigationFallbackId(fallbackId) {
return {
type: "RECEIVE_NAVIGATION_FALLBACK_ID",
fallbackId
};
}
function receiveDefaultTemplateId(query, templateId) {
return {
type: "RECEIVE_DEFAULT_TEMPLATE",
query,
templateId
};
}
var receiveRevisions = (kind, name, recordKey, records, query, invalidateCache = false, meta) => async ({ dispatch, resolveSelect }) => {
(0, import_log_entity_deprecation.default)(kind, name, "receiveRevisions");
const configs = await resolveSelect.getEntitiesConfig(kind);
const entityConfig = configs.find(
(config) => config.kind === kind && config.name === name
);
const key = entityConfig && entityConfig?.revisionKey ? entityConfig.revisionKey : import_entities.DEFAULT_ENTITY_KEY;
dispatch({
type: "RECEIVE_ITEM_REVISIONS",
key,
items: Array.isArray(records) ? records : [records],
recordKey,
meta,
query,
kind,
name,
invalidateCache
});
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
__experimentalBatch,
__experimentalReceiveCurrentGlobalStylesId,
__experimentalReceiveThemeBaseGlobalStyles,
__experimentalReceiveThemeGlobalStyleVariations,
__experimentalSaveSpecifiedEntityEdits,
__unstableCreateUndoLevel,
addEntities,
deleteEntityRecord,
editEntityRecord,
receiveAutosaves,
receiveCurrentTheme,
receiveCurrentUser,
receiveDefaultTemplateId,
receiveEmbedPreview,
receiveEntityRecords,
receiveNavigationFallbackId,
receiveRevisions,
receiveThemeGlobalStyleRevisions,
receiveThemeSupports,
receiveUploadPermissions,
receiveUserPermission,
receiveUserPermissions,
receiveUserQuery,
redo,
saveEditedEntityRecord,
saveEntityRecord,
undo
});
//# sourceMappingURL=actions.js.map