@wordpress/core-data 6.11.0 → 6.12.0

package/build-module/actions.js

@@ -18,6 +18,7 @@ import { receiveItems, removeItems, receiveQueriedItems } from './queried-data';
 import { getOrLoadEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 import { createBatch } from './batch';
 import { STORE_NAME } from './name';
+import { getUndoEdits, getRedoEdits } from './private-selectors';
 /**
  * Returns an action object used in signalling that authors have been received.
  * Ignored from documentation as it's internal to the data store.
@@ -80,10 +81,7 @@ export function addEntities(entities) {
  * @return {Object} Action object.
  */
 
-export 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;
-
+export 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') {
@@ -249,71 +247,67 @@ export function receiveEmbedPreview(url, preview) {
  *                                                the exceptions. Defaults to false.
  */
 
-export const deleteEntityRecord = function (kind, name, recordId, query) {
-  let {
-    __unstableFetch = apiFetch,
-    throwOnError = false
-  } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-  return async _ref => {
-    let {
-      dispatch
-    } = _ref;
-    const configs = await dispatch(getOrLoadEntitiesConfig(kind));
-    const entityConfig = configs.find(config => config.kind === kind && config.name === name);
-    let error;
-    let deletedRecord = false;
+export const deleteEntityRecord = (kind, name, recordId, query, {
+  __unstableFetch = apiFetch,
+  throwOnError = false
+} = {}) => async ({
+  dispatch
+}) => {
+  const configs = await dispatch(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(STORE_NAME, ['entities', 'records', kind, name, recordId], {
-      exclusive: true
+  const lock = await dispatch.__unstableAcquireStoreLock(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;
+      let path = `${entityConfig.baseURL}/${recordId}`;
 
-      try {
-        let path = `${entityConfig.baseURL}/${recordId}`;
-
-        if (query) {
-          path = addQueryArgs(path, query);
-        }
-
-        deletedRecord = await __unstableFetch({
-          path,
-          method: 'DELETE'
-        });
-        await dispatch(removeItems(kind, name, recordId, true));
-      } catch (_error) {
-        hasError = true;
-        error = _error;
+      if (query) {
+        path = addQueryArgs(path, query);
       }
 
-      dispatch({
-        type: 'DELETE_ENTITY_RECORD_FINISH',
-        kind,
-        name,
-        recordId,
-        error
+      deletedRecord = await __unstableFetch({
+        path,
+        method: 'DELETE'
       });
+      await dispatch(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
@@ -329,79 +323,72 @@ export const deleteEntityRecord = function (kind, name, recordId, query) {
  * @return {Object} Action object.
  */
 
-export 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.`);
-    }
+export 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] = fastDeepEqual(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] = fastDeepEqual(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
  * an entity record, if any.
  */
 
-export const undo = () => _ref3 => {
-  let {
-    select,
-    dispatch
-  } = _ref3;
-  const undoEdit = select.getUndoEdit();
+export const undo = () => ({
+  select,
+  dispatch
+}) => {
+  // Todo: we shouldn't have to pass "root" here.
+  const undoEdit = select(state => getUndoEdits(state.root));
 
   if (!undoEdit) {
     return;
   }
 
   dispatch({
-    type: 'EDIT_ENTITY_RECORD',
-    ...undoEdit,
-    meta: {
-      isUndo: true
-    }
+    type: 'UNDO',
+    stackedEdits: undoEdit
   });
 };
 /**
@@ -409,23 +396,20 @@ export const undo = () => _ref3 => {
  * edit to an entity record, if any.
  */
 
-export const redo = () => _ref4 => {
-  let {
-    select,
-    dispatch
-  } = _ref4;
-  const redoEdit = select.getRedoEdit();
+export const redo = () => ({
+  select,
+  dispatch
+}) => {
+  // Todo: we shouldn't have to pass "root" here.
+  const redoEdit = select(state => getRedoEdits(state.root));
 
   if (!redoEdit) {
     return;
   }
 
   dispatch({
-    type: 'EDIT_ENTITY_RECORD',
-    ...redoEdit,
-    meta: {
-      isRedo: true
-    }
+    type: 'REDO',
+    stackedEdits: redoEdit
   });
 };
 /**
@@ -454,157 +438,153 @@ export function __unstableCreateUndoLevel() {
  *                                                the exceptions. Defaults to false.
  */
 
-export const saveEntityRecord = function (kind, name, record) {
-  let {
-    isAutosave = false,
-    __unstableFetch = apiFetch,
-    throwOnError = false
-  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  return async _ref5 => {
-    let {
-      select,
-      resolveSelect,
-      dispatch
-    } = _ref5;
-    const configs = await dispatch(getOrLoadEntitiesConfig(kind));
-    const entityConfig = configs.find(config => config.kind === kind && config.name === name);
-
-    if (!entityConfig || entityConfig !== null && entityConfig !== void 0 && entityConfig.__experimentalNoFetch) {
-      return;
+export const saveEntityRecord = (kind, name, record, {
+  isAutosave = false,
+  __unstableFetch = apiFetch,
+  throwOnError = false
+} = {}) => async ({
+  select,
+  resolveSelect,
+  dispatch
+}) => {
+  const configs = await dispatch(getOrLoadEntitiesConfig(kind));
+  const entityConfig = configs.find(config => config.kind === kind && config.name === name);
+
+  if (!entityConfig || entityConfig?.__experimentalNoFetch) {
+    return;
+  }
+
+  const entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;
+  const recordId = record[entityIdKey];
+  const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'records', kind, name, recordId || uuid()], {
+    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 || DEFAULT_ENTITY_KEY;
-    const recordId = record[entityIdKey];
-    const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'records', kind, name, recordId || uuid()], {
-      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.
@@ -629,10 +609,9 @@ export const saveEntityRecord = function (kind, name, record) {
  *                                          values of each function given in `requests`.
  */
 
-export const __experimentalBatch = requests => async _ref6 => {
-  let {
-    dispatch
-  } = _ref6;
+export const __experimentalBatch = requests => async ({
+  dispatch
+}) => {
   const batch = createBatch();
   const api = {
     saveEntityRecord(kind, name, record, options) {
@@ -667,12 +646,10 @@ export const __experimentalBatch = requests => async _ref6 => {
  * @param {Object} options  Saving options.
  */
 
-export const saveEditedEntityRecord = (kind, name, recordId, options) => async _ref7 => {
-  let {
-    select,
-    dispatch
-  } = _ref7;
-
+export const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
+  select,
+  dispatch
+}) => {
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
@@ -702,12 +679,10 @@ export const saveEditedEntityRecord = (kind, name, recordId, options) => async _
  * @param {Object} options     Saving options.
  */
 
-export const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async _ref8 => {
-  let {
-    select,
-    dispatch
-  } = _ref8;
-
+export const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({
+  select,
+  dispatch
+}) => {
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }