@wordpress/core-data 6.11.0 → 6.12.0

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+## 6.12.0 (2023-06-07)
+
 ## 6.11.0 (2023-05-24)
 
 ## 6.10.0 (2023-05-10)

package/README.md

@@ -535,6 +535,8 @@ _Returns_
 
 ### getRedoEdit
 
+> **Deprecated** since 6.3
+
 Returns the next edit from the current undo offset for the entity records edits history, if any.
 
 _Parameters_
@@ -578,6 +580,8 @@ _Returns_
 
 ### getUndoEdit
 
+> **Deprecated** since 6.3
+
 Returns the previous edit from the current undo offset for the entity records edits history, if any.
 
 _Parameters_

package/build/actions.js

@@ -44,6 +44,8 @@ var _batch = require("./batch");
 
 var _name = require("./name");
 
+var _privateSelectors = require("./private-selectors");
+
 /**
  * External dependencies
  */
@@ -120,10 +122,7 @@ function addEntities(entities) {
  */
 
 
-function receiveEntityRecords(kind, name, records, query) {
-  let invalidateCache = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-  let edits = arguments.length > 5 ? arguments[5] : undefined;
-
+function receiveEntityRecords(kind, name, records, query, invalidateCache = false, edits) {
   // Auto drafts should not have titles, but some plugins rely on them so we can't filter this
   // on the server.
   if (kind === 'postType') {
@@ -297,71 +296,67 @@ function receiveEmbedPreview(url, preview) {
  */
 
 
-const deleteEntityRecord = function (kind, name, recordId, query) {
-  let {
-    __unstableFetch = _apiFetch.default,
-    throwOnError = false
-  } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-  return async _ref => {
-    let {
-      dispatch
-    } = _ref;
-    const configs = await dispatch((0, _entities.getOrLoadEntitiesConfig)(kind));
-    const entityConfig = configs.find(config => config.kind === kind && config.name === name);
-    let error;
-    let deletedRecord = false;
+const deleteEntityRecord = (kind, name, recordId, query, {
+  __unstableFetch = _apiFetch.default,
+  throwOnError = false
+} = {}) => async ({
+  dispatch
+}) => {
+  const configs = await dispatch((0, _entities.getOrLoadEntitiesConfig)(kind));
+  const entityConfig = configs.find(config => config.kind === kind && config.name === name);
+  let error;
+  let deletedRecord = false;
 
-    if (!entityConfig || entityConfig !== null && entityConfig !== void 0 && entityConfig.__experimentalNoFetch) {
-      return;
-    }
+  if (!entityConfig || entityConfig?.__experimentalNoFetch) {
+    return;
+  }
+
+  const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'records', kind, name, recordId], {
+    exclusive: true
+  });
 
-    const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'records', kind, name, recordId], {
-      exclusive: true
+  try {
+    dispatch({
+      type: 'DELETE_ENTITY_RECORD_START',
+      kind,
+      name,
+      recordId
     });
+    let hasError = false;
 
     try {
-      dispatch({
-        type: 'DELETE_ENTITY_RECORD_START',
-        kind,
-        name,
-        recordId
-      });
-      let hasError = false;
-
-      try {
-        let path = `${entityConfig.baseURL}/${recordId}`;
-
-        if (query) {
-          path = (0, _url.addQueryArgs)(path, query);
-        }
+      let path = `${entityConfig.baseURL}/${recordId}`;
 
-        deletedRecord = await __unstableFetch({
-          path,
-          method: 'DELETE'
-        });
-        await dispatch((0, _queriedData.removeItems)(kind, name, recordId, true));
-      } catch (_error) {
-        hasError = true;
-        error = _error;
+      if (query) {
+        path = (0, _url.addQueryArgs)(path, query);
       }
 
-      dispatch({
-        type: 'DELETE_ENTITY_RECORD_FINISH',
-        kind,
-        name,
-        recordId,
-        error
+      deletedRecord = await __unstableFetch({
+        path,
+        method: 'DELETE'
       });
+      await dispatch((0, _queriedData.removeItems)(kind, name, recordId, true));
+    } catch (_error) {
+      hasError = true;
+      error = _error;
+    }
 
-      if (hasError && throwOnError) {
-        throw error;
-      }
+    dispatch({
+      type: 'DELETE_ENTITY_RECORD_FINISH',
+      kind,
+      name,
+      recordId,
+      error
+    });
 
-      return deletedRecord;
-    } finally {
-      dispatch.__unstableReleaseStoreLock(lock);
+    if (hasError && throwOnError) {
+      throw error;
     }
-  };
+
+    return deletedRecord;
+  } finally {
+    dispatch.__unstableReleaseStoreLock(lock);
+  }
 };
 /**
  * Returns an action object that triggers an
@@ -380,56 +375,52 @@ const deleteEntityRecord = function (kind, name, recordId, query) {
 
 exports.deleteEntityRecord = deleteEntityRecord;
 
-const editEntityRecord = function (kind, name, recordId, edits) {
-  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-  return _ref2 => {
-    let {
-      select,
-      dispatch
-    } = _ref2;
-    const entityConfig = select.getEntityConfig(kind, name);
-
-    if (!entityConfig) {
-      throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
-    }
+const editEntityRecord = (kind, name, recordId, edits, options = {}) => ({
+  select,
+  dispatch
+}) => {
+  const entityConfig = select.getEntityConfig(kind, name);
 
-    const {
-      transientEdits = {},
-      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, _es.default)(recordValue, value) ? undefined : value;
-        return acc;
-      }, {}),
-      transientEdits
-    };
-    dispatch({
-      type: 'EDIT_ENTITY_RECORD',
-      ...edit,
-      meta: {
-        undo: !options.undoIgnore && { ...edit,
-          // Send the current values for things like the first undo stack entry.
-          edits: Object.keys(edits).reduce((acc, key) => {
-            acc[key] = editedRecord[key];
-            return acc;
-          }, {})
-        }
-      }
-    });
+  if (!entityConfig) {
+    throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
+  }
+
+  const {
+    transientEdits = {},
+    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, _es.default)(recordValue, value) ? undefined : value;
+      return acc;
+    }, {}),
+    transientEdits
   };
+  dispatch({
+    type: 'EDIT_ENTITY_RECORD',
+    ...edit,
+    meta: {
+      undo: !options.undoIgnore && { ...edit,
+        // Send the current values for things like the first undo stack entry.
+        edits: Object.keys(edits).reduce((acc, key) => {
+          acc[key] = editedRecord[key];
+          return acc;
+        }, {})
+      }
+    }
+  });
 };
 /**
  * Action triggered to undo the last edit to
@@ -439,23 +430,20 @@ const editEntityRecord = function (kind, name, recordId, edits) {
 
 exports.editEntityRecord = editEntityRecord;
 
-const undo = () => _ref3 => {
-  let {
-    select,
-    dispatch
-  } = _ref3;
-  const undoEdit = select.getUndoEdit();
+const undo = () => ({
+  select,
+  dispatch
+}) => {
+  // Todo: we shouldn't have to pass "root" here.
+  const undoEdit = select(state => (0, _privateSelectors.getUndoEdits)(state.root));
 
   if (!undoEdit) {
     return;
   }
 
   dispatch({
-    type: 'EDIT_ENTITY_RECORD',
-    ...undoEdit,
-    meta: {
-      isUndo: true
-    }
+    type: 'UNDO',
+    stackedEdits: undoEdit
   });
 };
 /**
@@ -466,23 +454,20 @@ const undo = () => _ref3 => {
 
 exports.undo = undo;
 
-const redo = () => _ref4 => {
-  let {
-    select,
-    dispatch
-  } = _ref4;
-  const redoEdit = select.getRedoEdit();
+const redo = () => ({
+  select,
+  dispatch
+}) => {
+  // Todo: we shouldn't have to pass "root" here.
+  const redoEdit = select(state => (0, _privateSelectors.getRedoEdits)(state.root));
 
   if (!redoEdit) {
     return;
   }
 
   dispatch({
-    type: 'EDIT_ENTITY_RECORD',
-    ...redoEdit,
-    meta: {
-      isRedo: true
-    }
+    type: 'REDO',
+    stackedEdits: redoEdit
   });
 };
 /**
@@ -515,157 +500,153 @@ function __unstableCreateUndoLevel() {
  */
 
 
-const saveEntityRecord = function (kind, name, record) {
-  let {
-    isAutosave = false,
-    __unstableFetch = _apiFetch.default,
-    throwOnError = false
-  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  return async _ref5 => {
-    let {
-      select,
-      resolveSelect,
-      dispatch
-    } = _ref5;
-    const configs = await dispatch((0, _entities.getOrLoadEntitiesConfig)(kind));
-    const entityConfig = configs.find(config => config.kind === kind && config.name === name);
-
-    if (!entityConfig || entityConfig !== null && entityConfig !== void 0 && entityConfig.__experimentalNoFetch) {
-      return;
+const saveEntityRecord = (kind, name, record, {
+  isAutosave = false,
+  __unstableFetch = _apiFetch.default,
+  throwOnError = false
+} = {}) => async ({
+  select,
+  resolveSelect,
+  dispatch
+}) => {
+  const configs = await dispatch((0, _entities.getOrLoadEntitiesConfig)(kind));
+  const entityConfig = configs.find(config => config.kind === kind && config.name === name);
+
+  if (!entityConfig || entityConfig?.__experimentalNoFetch) {
+    return;
+  }
+
+  const entityIdKey = entityConfig.key || _entities.DEFAULT_ENTITY_KEY;
+  const recordId = record[entityIdKey];
+  const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'records', kind, name, recordId || (0, _uuid.v4)()], {
+    exclusive: true
+  });
+
+  try {
+    // Evaluate optimized edits.
+    // (Function edits that should be evaluated on save to avoid expensive computations on every edit.)
+    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;
+      }
     }
 
-    const entityIdKey = entityConfig.key || _entities.DEFAULT_ENTITY_KEY;
-    const recordId = record[entityIdKey];
-    const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'records', kind, name, recordId || (0, _uuid.v4)()], {
-      exclusive: true
+    dispatch({
+      type: 'SAVE_ENTITY_RECORD_START',
+      kind,
+      name,
+      recordId,
+      isAutosave
     });
+    let updatedRecord;
+    let error;
+    let hasError = false;
 
     try {
-      // Evaluate optimized edits.
-      // (Function edits that should be evaluated on save to avoid expensive computations on every edit.)
-      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;
-        }
-      }
+      const path = `${entityConfig.baseURL}${recordId ? '/' + recordId : ''}`;
+      const persistedRecord = select.getRawEntityRecord(kind, name, recordId);
+
+      if (isAutosave) {
+        // Most of this autosave logic is very specific to posts.
+        // This is fine for now as it is the only supported autosave,
+        // but ideally this should all be handled in the back end,
+        // so the client just sends and receives objects.
+        const currentUser = select.getCurrentUser();
+        const currentUserId = currentUser ? currentUser.id : undefined;
+        const autosavePost = await resolveSelect.getAutosave(persistedRecord.type, persistedRecord.id, currentUserId); // Autosaves need all expected fields to be present.
+        // So we fallback to the previous autosave and then
+        // to the actual persisted entity if the edits don't
+        // have a value.
+
+        let data = { ...persistedRecord,
+          ...autosavePost,
+          ...record
+        };
+        data = Object.keys(data).reduce((acc, key) => {
+          if (['title', 'excerpt', 'content'].includes(key)) {
+            acc[key] = data[key];
+          }
 
-      dispatch({
-        type: 'SAVE_ENTITY_RECORD_START',
-        kind,
-        name,
-        recordId,
-        isAutosave
-      });
-      let updatedRecord;
-      let error;
-      let hasError = false;
-
-      try {
-        const path = `${entityConfig.baseURL}${recordId ? '/' + recordId : ''}`;
-        const persistedRecord = select.getRawEntityRecord(kind, name, recordId);
-
-        if (isAutosave) {
-          // Most of this autosave logic is very specific to posts.
-          // This is fine for now as it is the only supported autosave,
-          // but ideally this should all be handled in the back end,
-          // so the client just sends and receives objects.
-          const currentUser = select.getCurrentUser();
-          const currentUserId = currentUser ? currentUser.id : undefined;
-          const autosavePost = await resolveSelect.getAutosave(persistedRecord.type, persistedRecord.id, currentUserId); // Autosaves need all expected fields to be present.
-          // So we fallback to the previous autosave and then
-          // to the actual persisted entity if the edits don't
-          // have a value.
-
-          let data = { ...persistedRecord,
-            ...autosavePost,
-            ...record
+          return acc;
+        }, {
+          status: data.status === 'auto-draft' ? 'draft' : data.status
+        });
+        updatedRecord = await __unstableFetch({
+          path: `${path}/autosaves`,
+          method: 'POST',
+          data
+        }); // An autosave may be processed by the server as a regular save
+        // when its update is requested by the author and the post had
+        // draft or auto-draft status.
+
+        if (persistedRecord.id === updatedRecord.id) {
+          let newRecord = { ...persistedRecord,
+            ...data,
+            ...updatedRecord
           };
-          data = Object.keys(data).reduce((acc, key) => {
+          newRecord = Object.keys(newRecord).reduce((acc, key) => {
+            // These properties are persisted in autosaves.
             if (['title', 'excerpt', 'content'].includes(key)) {
-              acc[key] = data[key];
+              acc[key] = newRecord[key];
+            } else if (key === 'status') {
+              // Status is only persisted in autosaves when going from
+              // "auto-draft" to "draft".
+              acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status;
+            } else {
+              // These properties are not persisted in autosaves.
+              acc[key] = persistedRecord[key];
             }
 
             return acc;
-          }, {
-            status: data.status === 'auto-draft' ? 'draft' : data.status
-          });
-          updatedRecord = await __unstableFetch({
-            path: `${path}/autosaves`,
-            method: 'POST',
-            data
-          }); // An autosave may be processed by the server as a regular save
-          // when its update is requested by the author and the post had
-          // draft or auto-draft status.
-
-          if (persistedRecord.id === updatedRecord.id) {
-            let newRecord = { ...persistedRecord,
-              ...data,
-              ...updatedRecord
-            };
-            newRecord = Object.keys(newRecord).reduce((acc, key) => {
-              // These properties are persisted in autosaves.
-              if (['title', 'excerpt', 'content'].includes(key)) {
-                acc[key] = newRecord[key];
-              } else if (key === 'status') {
-                // Status is only persisted in autosaves when going from
-                // "auto-draft" to "draft".
-                acc[key] = persistedRecord.status === 'auto-draft' && newRecord.status === 'draft' ? newRecord.status : persistedRecord.status;
-              } else {
-                // These properties are not persisted in autosaves.
-                acc[key] = persistedRecord[key];
-              }
-
-              return acc;
-            }, {});
-            dispatch.receiveEntityRecords(kind, name, newRecord, undefined, true);
-          } else {
-            dispatch.receiveAutosaves(persistedRecord.id, updatedRecord);
-          }
+          }, {});
+          dispatch.receiveEntityRecords(kind, name, newRecord, undefined, true);
         } 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, undefined, true, edits);
+          dispatch.receiveAutosaves(persistedRecord.id, updatedRecord);
         }
-      } catch (_error) {
-        hasError = true;
-        error = _error;
-      }
+      } else {
+        let edits = record;
 
-      dispatch({
-        type: 'SAVE_ENTITY_RECORD_FINISH',
-        kind,
-        name,
-        recordId,
-        error,
-        isAutosave
-      });
+        if (entityConfig.__unstablePrePersist) {
+          edits = { ...edits,
+            ...entityConfig.__unstablePrePersist(persistedRecord, edits)
+          };
+        }
 
-      if (hasError && throwOnError) {
-        throw error;
+        updatedRecord = await __unstableFetch({
+          path,
+          method: recordId ? 'PUT' : 'POST',
+          data: edits
+        });
+        dispatch.receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
       }
+    } catch (_error) {
+      hasError = true;
+      error = _error;
+    }
+
+    dispatch({
+      type: 'SAVE_ENTITY_RECORD_FINISH',
+      kind,
+      name,
+      recordId,
+      error,
+      isAutosave
+    });
 
-      return updatedRecord;
-    } finally {
-      dispatch.__unstableReleaseStoreLock(lock);
+    if (hasError && throwOnError) {
+      throw error;
     }
-  };
+
+    return updatedRecord;
+  } finally {
+    dispatch.__unstableReleaseStoreLock(lock);
+  }
 };
 /**
  * Runs multiple core-data actions at the same time using one API request.
@@ -693,10 +674,9 @@ const saveEntityRecord = function (kind, name, record) {
 
 exports.saveEntityRecord = saveEntityRecord;
 
-const __experimentalBatch = requests => async _ref6 => {
-  let {
-    dispatch
-  } = _ref6;
+const __experimentalBatch = requests => async ({
+  dispatch
+}) => {
   const batch = (0, _batch.createBatch)();
   const api = {
     saveEntityRecord(kind, name, record, options) {
@@ -734,12 +714,10 @@ const __experimentalBatch = requests => async _ref6 => {
 
 exports.__experimentalBatch = __experimentalBatch;
 
-const saveEditedEntityRecord = (kind, name, recordId, options) => async _ref7 => {
-  let {
-    select,
-    dispatch
-  } = _ref7;
-
+const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
+  select,
+  dispatch
+}) => {
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
@@ -772,12 +750,10 @@ const saveEditedEntityRecord = (kind, name, recordId, options) => async _ref7 =>
 
 exports.saveEditedEntityRecord = saveEditedEntityRecord;
 
-const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async _ref8 => {
-  let {
-    select,
-    dispatch
-  } = _ref8;
-
+const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({
+  select,
+  dispatch
+}) => {
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }