@wordpress/core-data 4.0.6 → 4.0.7

package/build-module/actions.js

@@ -74,7 +74,10 @@ export function addEntities(entities) {
  * @return {Object} Action object.
  */
 
-export function receiveEntityRecords(kind, name, records, query, invalidateCache = false, edits) {
+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;
+
   // Auto drafts should not have titles, but some plugins rely on them so we can't filter this
   // on the server.
   if (kind === 'postType') {
@@ -188,62 +191,66 @@ export function receiveEmbedPreview(url, preview) {
  *                                             Must return a promise.
  */
 
-export const deleteEntityRecord = (kind, name, recordId, query, {
-  __unstableFetch = apiFetch
-} = {}) => async ({
-  dispatch
-}) => {
-  const entities = await dispatch(getKindEntities(kind));
-  const entity = find(entities, {
-    kind,
-    name
-  });
-  let error;
-  let deletedRecord = false;
-
-  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
-    return;
-  }
+export const deleteEntityRecord = function (kind, name, recordId, query) {
+  let {
+    __unstableFetch = apiFetch
+  } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  return async _ref => {
+    let {
+      dispatch
+    } = _ref;
+    const entities = await dispatch(getKindEntities(kind));
+    const entity = find(entities, {
+      kind,
+      name
+    });
+    let error;
+    let deletedRecord = false;
 
-  const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId], {
-    exclusive: true
-  });
+    if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
+      return;
+    }
 
-  try {
-    dispatch({
-      type: 'DELETE_ENTITY_RECORD_START',
-      kind,
-      name,
-      recordId
+    const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId], {
+      exclusive: true
     });
 
     try {
-      let path = `${entity.baseURL}/${recordId}`;
+      dispatch({
+        type: 'DELETE_ENTITY_RECORD_START',
+        kind,
+        name,
+        recordId
+      });
 
-      if (query) {
-        path = addQueryArgs(path, query);
+      try {
+        let path = `${entity.baseURL}/${recordId}`;
+
+        if (query) {
+          path = addQueryArgs(path, query);
+        }
+
+        deletedRecord = await __unstableFetch({
+          path,
+          method: 'DELETE'
+        });
+        await dispatch(removeItems(kind, name, recordId, true));
+      } catch (_error) {
+        error = _error;
       }
 
-      deletedRecord = await __unstableFetch({
-        path,
-        method: 'DELETE'
+      dispatch({
+        type: 'DELETE_ENTITY_RECORD_FINISH',
+        kind,
+        name,
+        recordId,
+        error
       });
-      await dispatch(removeItems(kind, name, recordId, true));
-    } catch (_error) {
-      error = _error;
+      return deletedRecord;
+    } finally {
+      dispatch.__unstableReleaseStoreLock(lock);
     }
-
-    dispatch({
-      type: 'DELETE_ENTITY_RECORD_FINISH',
-      kind,
-      name,
-      recordId,
-      error
-    });
-    return deletedRecord;
-  } finally {
-    dispatch.__unstableReleaseStoreLock(lock);
-  }
+  };
 };
 /**
  * Returns an action object that triggers an
@@ -259,52 +266,56 @@ export const deleteEntityRecord = (kind, name, recordId, query, {
  * @return {Object} Action object.
  */
 
-export const editEntityRecord = (kind, name, recordId, edits, options = {}) => ({
-  select,
-  dispatch
-}) => {
-  const entity = select.getEntity(kind, name);
-
-  if (!entity) {
-    throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
-  }
+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 entity = select.getEntity(kind, name);
+
+    if (!entity) {
+      throw new Error(`The entity being edited (${kind}, ${name}) does not have a loaded config.`);
+    }
 
-  const {
-    transientEdits = {},
-    mergedEdits = {}
-  } = entity;
-  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] = isEqual(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;
-        }, {})
+    const {
+      transientEdits = {},
+      mergedEdits = {}
+    } = entity;
+    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] = isEqual(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
@@ -313,10 +324,11 @@ export const editEntityRecord = (kind, name, recordId, edits, options = {}) => (
  * @return {undefined}
  */
 
-export const undo = () => ({
-  select,
-  dispatch
-}) => {
+export const undo = () => _ref3 => {
+  let {
+    select,
+    dispatch
+  } = _ref3;
   const undoEdit = select.getUndoEdit();
 
   if (!undoEdit) {
@@ -338,10 +350,11 @@ export const undo = () => ({
  * @return {undefined}
  */
 
-export const redo = () => ({
-  select,
-  dispatch
-}) => {
+export const redo = () => _ref4 => {
+  let {
+    select,
+    dispatch
+  } = _ref4;
   const redoEdit = select.getRedoEdit();
 
   if (!redoEdit) {
@@ -380,148 +393,152 @@ export function __unstableCreateUndoLevel() {
  *                                              Must return a promise.
  */
 
-export const saveEntityRecord = (kind, name, record, {
-  isAutosave = false,
-  __unstableFetch = apiFetch
-} = {}) => async ({
-  select,
-  resolveSelect,
-  dispatch
-}) => {
-  const entities = await dispatch(getKindEntities(kind));
-  const entity = find(entities, {
-    kind,
-    name
-  });
-
-  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
-    return;
-  }
-
-  const entityIdKey = entity.key || DEFAULT_ENTITY_KEY;
-  const recordId = record[entityIdKey];
-  const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId || uuid()], {
-    exclusive: true
-  });
+export const saveEntityRecord = function (kind, name, record) {
+  let {
+    isAutosave = false,
+    __unstableFetch = apiFetch
+  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  return async _ref5 => {
+    let {
+      select,
+      resolveSelect,
+      dispatch
+    } = _ref5;
+    const entities = await dispatch(getKindEntities(kind));
+    const entity = find(entities, {
+      kind,
+      name
+    });
 
-  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;
-      }
+    if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
+      return;
     }
 
-    dispatch({
-      type: 'SAVE_ENTITY_RECORD_START',
-      kind,
-      name,
-      recordId,
-      isAutosave
+    const entityIdKey = entity.key || DEFAULT_ENTITY_KEY;
+    const recordId = record[entityIdKey];
+    const lock = await dispatch.__unstableAcquireStoreLock(STORE_NAME, ['entities', 'data', kind, name, recordId || uuid()], {
+      exclusive: true
     });
-    let updatedRecord;
-    let error;
 
     try {
-      const path = `${entity.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 = 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];
-          }
+      // 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;
+        }
+      }
 
-          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
+      dispatch({
+        type: 'SAVE_ENTITY_RECORD_START',
+        kind,
+        name,
+        recordId,
+        isAutosave
+      });
+      let updatedRecord;
+      let error;
+
+      try {
+        const path = `${entity.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 = 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
           };
-          newRecord = Object.keys(newRecord).reduce((acc, key) => {
-            // These properties are persisted in autosaves.
+          data = Object.keys(data).reduce((acc, key) => {
             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];
+              acc[key] = data[key];
             }
 
             return acc;
-          }, {});
-          dispatch.receiveEntityRecords(kind, name, newRecord, undefined, true);
+          }, {
+            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);
+          }
         } else {
-          dispatch.receiveAutosaves(persistedRecord.id, updatedRecord);
-        }
-      } else {
-        let edits = record;
+          let edits = record;
 
-        if (entity.__unstablePrePersist) {
-          edits = { ...edits,
-            ...entity.__unstablePrePersist(persistedRecord, edits)
-          };
-        }
+          if (entity.__unstablePrePersist) {
+            edits = { ...edits,
+              ...entity.__unstablePrePersist(persistedRecord, edits)
+            };
+          }
 
-        updatedRecord = await __unstableFetch({
-          path,
-          method: recordId ? 'PUT' : 'POST',
-          data: edits
-        });
-        dispatch.receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
+          updatedRecord = await __unstableFetch({
+            path,
+            method: recordId ? 'PUT' : 'POST',
+            data: edits
+          });
+          dispatch.receiveEntityRecords(kind, name, updatedRecord, undefined, true, edits);
+        }
+      } catch (_error) {
+        error = _error;
       }
-    } catch (_error) {
-      error = _error;
-    }
 
-    dispatch({
-      type: 'SAVE_ENTITY_RECORD_FINISH',
-      kind,
-      name,
-      recordId,
-      error,
-      isAutosave
-    });
-    return updatedRecord;
-  } finally {
-    dispatch.__unstableReleaseStoreLock(lock);
-  }
+      dispatch({
+        type: 'SAVE_ENTITY_RECORD_FINISH',
+        kind,
+        name,
+        recordId,
+        error,
+        isAutosave
+      });
+      return updatedRecord;
+    } finally {
+      dispatch.__unstableReleaseStoreLock(lock);
+    }
+  };
 };
 /**
  * Runs multiple core-data actions at the same time using one API request.
@@ -546,9 +563,10 @@ export const saveEntityRecord = (kind, name, record, {
  *                   values of each function given in `requests`.
  */
 
-export const __experimentalBatch = requests => async ({
-  dispatch
-}) => {
+export const __experimentalBatch = requests => async _ref6 => {
+  let {
+    dispatch
+  } = _ref6;
   const batch = createBatch();
   const api = {
     saveEntityRecord(kind, name, record, options) {
@@ -583,10 +601,12 @@ export const __experimentalBatch = requests => async ({
  * @param {Object} options  Saving options.
  */
 
-export const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
-  select,
-  dispatch
-}) => {
+export const saveEditedEntityRecord = (kind, name, recordId, options) => async _ref7 => {
+  let {
+    select,
+    dispatch
+  } = _ref7;
+
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
@@ -619,10 +639,12 @@ export const saveEditedEntityRecord = (kind, name, recordId, options) => async (
  * @param {Object} options     Saving options.
  */
 
-export const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({
-  select,
-  dispatch
-}) => {
+export const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async _ref8 => {
+  let {
+    select,
+    dispatch
+  } = _ref8;
+
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }