@wordpress/core-data 4.0.6 → 4.0.7

package/build/actions.js

@@ -5,20 +5,23 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.receiveUserQuery = receiveUserQuery;
-exports.receiveCurrentUser = receiveCurrentUser;
-exports.addEntities = addEntities;
-exports.receiveEntityRecords = receiveEntityRecords;
-exports.receiveCurrentTheme = receiveCurrentTheme;
+exports.__experimentalBatch = void 0;
 exports.__experimentalReceiveCurrentGlobalStylesId = __experimentalReceiveCurrentGlobalStylesId;
 exports.__experimentalReceiveThemeBaseGlobalStyles = __experimentalReceiveThemeBaseGlobalStyles;
-exports.receiveThemeSupports = receiveThemeSupports;
-exports.receiveEmbedPreview = receiveEmbedPreview;
+exports.__experimentalSaveSpecifiedEntityEdits = void 0;
 exports.__unstableCreateUndoLevel = __unstableCreateUndoLevel;
+exports.addEntities = addEntities;
+exports.editEntityRecord = exports.deleteEntityRecord = void 0;
+exports.receiveAutosaves = receiveAutosaves;
+exports.receiveCurrentTheme = receiveCurrentTheme;
+exports.receiveCurrentUser = receiveCurrentUser;
+exports.receiveEmbedPreview = receiveEmbedPreview;
+exports.receiveEntityRecords = receiveEntityRecords;
+exports.receiveThemeSupports = receiveThemeSupports;
 exports.receiveUploadPermissions = receiveUploadPermissions;
 exports.receiveUserPermission = receiveUserPermission;
-exports.receiveAutosaves = receiveAutosaves;
-exports.__experimentalSaveSpecifiedEntityEdits = exports.saveEditedEntityRecord = exports.__experimentalBatch = exports.saveEntityRecord = exports.redo = exports.undo = exports.editEntityRecord = exports.deleteEntityRecord = void 0;
+exports.receiveUserQuery = receiveUserQuery;
+exports.undo = exports.saveEntityRecord = exports.saveEditedEntityRecord = exports.redo = void 0;
 
 var _lodash = require("lodash");
 
@@ -108,7 +111,10 @@ function addEntities(entities) {
  */
 
 
-function receiveEntityRecords(kind, name, records, query, invalidateCache = false, edits) {
+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') {
@@ -228,62 +234,66 @@ function receiveEmbedPreview(url, preview) {
  */
 
 
-const deleteEntityRecord = (kind, name, recordId, query, {
-  __unstableFetch = _apiFetch.default
-} = {}) => async ({
-  dispatch
-}) => {
-  const entities = await dispatch((0, _entities.getKindEntities)(kind));
-  const entity = (0, _lodash.find)(entities, {
-    kind,
-    name
-  });
-  let error;
-  let deletedRecord = false;
-
-  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
-    return;
-  }
+const deleteEntityRecord = function (kind, name, recordId, query) {
+  let {
+    __unstableFetch = _apiFetch.default
+  } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  return async _ref => {
+    let {
+      dispatch
+    } = _ref;
+    const entities = await dispatch((0, _entities.getKindEntities)(kind));
+    const entity = (0, _lodash.find)(entities, {
+      kind,
+      name
+    });
+    let error;
+    let deletedRecord = false;
 
-  const lock = await dispatch.__unstableAcquireStoreLock(_name.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(_name.STORE_NAME, ['entities', 'data', kind, name, recordId], {
+      exclusive: true
     });
 
     try {
-      let path = `${entity.baseURL}/${recordId}`;
+      dispatch({
+        type: 'DELETE_ENTITY_RECORD_START',
+        kind,
+        name,
+        recordId
+      });
+
+      try {
+        let path = `${entity.baseURL}/${recordId}`;
 
-      if (query) {
-        path = (0, _url.addQueryArgs)(path, query);
+        if (query) {
+          path = (0, _url.addQueryArgs)(path, query);
+        }
+
+        deletedRecord = await __unstableFetch({
+          path,
+          method: 'DELETE'
+        });
+        await dispatch((0, _queriedData.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((0, _queriedData.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
@@ -302,52 +312,56 @@ const deleteEntityRecord = (kind, name, recordId, query, {
 
 exports.deleteEntityRecord = deleteEntityRecord;
 
-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.`);
-  }
+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] = (0, _lodash.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] = (0, _lodash.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
@@ -359,10 +373,11 @@ const editEntityRecord = (kind, name, recordId, edits, options = {}) => ({
 
 exports.editEntityRecord = editEntityRecord;
 
-const undo = () => ({
-  select,
-  dispatch
-}) => {
+const undo = () => _ref3 => {
+  let {
+    select,
+    dispatch
+  } = _ref3;
   const undoEdit = select.getUndoEdit();
 
   if (!undoEdit) {
@@ -387,10 +402,11 @@ const undo = () => ({
 
 exports.undo = undo;
 
-const redo = () => ({
-  select,
-  dispatch
-}) => {
+const redo = () => _ref4 => {
+  let {
+    select,
+    dispatch
+  } = _ref4;
   const redoEdit = select.getRedoEdit();
 
   if (!redoEdit) {
@@ -433,148 +449,152 @@ function __unstableCreateUndoLevel() {
  */
 
 
-const saveEntityRecord = (kind, name, record, {
-  isAutosave = false,
-  __unstableFetch = _apiFetch.default
-} = {}) => async ({
-  select,
-  resolveSelect,
-  dispatch
-}) => {
-  const entities = await dispatch((0, _entities.getKindEntities)(kind));
-  const entity = (0, _lodash.find)(entities, {
-    kind,
-    name
-  });
-
-  if (!entity || entity !== null && entity !== void 0 && entity.__experimentalNoFetch) {
-    return;
-  }
-
-  const entityIdKey = entity.key || _entities.DEFAULT_ENTITY_KEY;
-  const recordId = record[entityIdKey];
-  const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'data', kind, name, recordId || (0, _uuid.v4)()], {
-    exclusive: true
-  });
+const saveEntityRecord = function (kind, name, record) {
+  let {
+    isAutosave = false,
+    __unstableFetch = _apiFetch.default
+  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  return async _ref5 => {
+    let {
+      select,
+      resolveSelect,
+      dispatch
+    } = _ref5;
+    const entities = await dispatch((0, _entities.getKindEntities)(kind));
+    const entity = (0, _lodash.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 || _entities.DEFAULT_ENTITY_KEY;
+    const recordId = record[entityIdKey];
+    const lock = await dispatch.__unstableAcquireStoreLock(_name.STORE_NAME, ['entities', 'data', kind, name, recordId || (0, _uuid.v4)()], {
+      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.
@@ -602,9 +622,10 @@ const saveEntityRecord = (kind, name, record, {
 
 exports.saveEntityRecord = saveEntityRecord;
 
-const __experimentalBatch = requests => async ({
-  dispatch
-}) => {
+const __experimentalBatch = requests => async _ref6 => {
+  let {
+    dispatch
+  } = _ref6;
   const batch = (0, _batch.createBatch)();
   const api = {
     saveEntityRecord(kind, name, record, options) {
@@ -642,10 +663,12 @@ const __experimentalBatch = requests => async ({
 
 exports.__experimentalBatch = __experimentalBatch;
 
-const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
-  select,
-  dispatch
-}) => {
+const saveEditedEntityRecord = (kind, name, recordId, options) => async _ref7 => {
+  let {
+    select,
+    dispatch
+  } = _ref7;
+
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }
@@ -681,10 +704,12 @@ const saveEditedEntityRecord = (kind, name, recordId, options) => async ({
 
 exports.saveEditedEntityRecord = saveEditedEntityRecord;
 
-const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({
-  select,
-  dispatch
-}) => {
+const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async _ref8 => {
+  let {
+    select,
+    dispatch
+  } = _ref8;
+
   if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
     return;
   }