@wordpress/core-data 4.8.0 → 4.9.0

package/src/actions.js

@@ -221,71 +221,73 @@ export function receiveEmbedPreview( url, preview ) {
  * @param {boolean}  [options.throwOnError=false] If false, this action suppresses all
  *                                                the exceptions. Defaults to false.
  */
-export const deleteEntityRecord = (
-	kind,
-	name,
-	recordId,
-	query,
-	{ __unstableFetch = apiFetch, throwOnError = false } = {}
-) => async ( { dispatch } ) => {
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, name } );
-	let error;
-	let deletedRecord = false;
-	if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
-		return;
-	}
-
-	const lock = await dispatch.__unstableAcquireStoreLock(
-		STORE_NAME,
-		[ 'entities', 'records', kind, name, recordId ],
-		{ exclusive: true }
-	);
+export const deleteEntityRecord =
+	(
+		kind,
+		name,
+		recordId,
+		query,
+		{ __unstableFetch = apiFetch, throwOnError = false } = {}
+	) =>
+	async ( { dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, name } );
+		let error;
+		let deletedRecord = false;
+		if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
+			return;
+		}
 
-	try {
-		dispatch( {
-			type: 'DELETE_ENTITY_RECORD_START',
-			kind,
-			name,
-			recordId,
-		} );
+		const lock = await dispatch.__unstableAcquireStoreLock(
+			STORE_NAME,
+			[ 'entities', 'records', kind, name, recordId ],
+			{ exclusive: true }
+		);
 
-		let hasError = false;
 		try {
-			let path = `${ entityConfig.baseURL }/${ recordId }`;
+			dispatch( {
+				type: 'DELETE_ENTITY_RECORD_START',
+				kind,
+				name,
+				recordId,
+			} );
+
+			let hasError = false;
+			try {
+				let path = `${ entityConfig.baseURL }/${ recordId }`;
+
+				if ( query ) {
+					path = addQueryArgs( path, query );
+				}
 
-			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;
 			}
 
-			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 ) {
-			hasError = true;
-			error = _error;
-		}
-
-		dispatch( {
-			type: 'DELETE_ENTITY_RECORD_FINISH',
-			kind,
-			name,
-			recordId,
-			error,
-		} );
+			if ( hasError && throwOnError ) {
+				throw error;
+			}
 
-		if ( hasError && throwOnError ) {
-			throw error;
+			return deletedRecord;
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
 		}
-
-		return deletedRecord;
-	} finally {
-		dispatch.__unstableReleaseStoreLock( lock );
-	}
-};
+	};
 
 /**
  * Returns an action object that triggers an
@@ -300,87 +302,91 @@ export const deleteEntityRecord = (
  *
  * @return {Object} Action object.
  */
-export const editEntityRecord = (
-	kind,
-	name,
-	recordId,
-	edits,
-	options = {}
-) => ( { select, dispatch } ) => {
-	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 );
+		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 { 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 ] = 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 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
  * an entity record, if any.
  */
-export const undo = () => ( { select, dispatch } ) => {
-	const undoEdit = select.getUndoEdit();
-	if ( ! undoEdit ) {
-		return;
-	}
-	dispatch( {
-		type: 'EDIT_ENTITY_RECORD',
-		...undoEdit,
-		meta: { isUndo: true },
-	} );
-};
+export const undo =
+	() =>
+	( { select, dispatch } ) => {
+		const undoEdit = select.getUndoEdit();
+		if ( ! undoEdit ) {
+			return;
+		}
+		dispatch( {
+			type: 'EDIT_ENTITY_RECORD',
+			...undoEdit,
+			meta: { isUndo: true },
+		} );
+	};
 
 /**
  * Action triggered to redo the last undoed
  * edit to an entity record, if any.
  */
-export const redo = () => ( { select, dispatch } ) => {
-	const redoEdit = select.getRedoEdit();
-	if ( ! redoEdit ) {
-		return;
-	}
-	dispatch( {
-		type: 'EDIT_ENTITY_RECORD',
-		...redoEdit,
-		meta: { isRedo: true },
-	} );
-};
+export const redo =
+	() =>
+	( { select, dispatch } ) => {
+		const redoEdit = select.getRedoEdit();
+		if ( ! redoEdit ) {
+			return;
+		}
+		dispatch( {
+			type: 'EDIT_ENTITY_RECORD',
+			...redoEdit,
+			meta: { isRedo: true },
+		} );
+	};
 
 /**
  * Forces the creation of a new undo level.
@@ -405,204 +411,215 @@ export function __unstableCreateUndoLevel() {
  * @param {boolean}  [options.throwOnError=false] If false, this action suppresses all
  *                                                the exceptions. Defaults to false.
  */
-export const saveEntityRecord = (
-	kind,
-	name,
-	record,
-	{
-		isAutosave = false,
-		__unstableFetch = apiFetch,
-		throwOnError = false,
-	} = {}
-) => async ( { select, resolveSelect, dispatch } ) => {
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, 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;
-			}
+export const saveEntityRecord =
+	(
+		kind,
+		name,
+		record,
+		{
+			isAutosave = false,
+			__unstableFetch = apiFetch,
+			throwOnError = false,
+		} = {}
+	) =>
+	async ( { select, resolveSelect, dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, 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 }
+		);
 
-		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(
+			// 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;
+				}
+			}
+
+			dispatch( {
+				type: 'SAVE_ENTITY_RECORD_START',
 				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 ];
-						}
-						return acc;
-					},
-					{
-						status:
-							data.status === 'auto-draft'
-								? 'draft'
-								: data.status,
-					}
+				recordId,
+				isAutosave,
+			} );
+			let updatedRecord;
+			let error;
+			let hasError = false;
+			try {
+				const path = `${ entityConfig.baseURL }${
+					recordId ? '/' + recordId : ''
+				}`;
+				const persistedRecord = select.getRawEntityRecord(
+					kind,
+					name,
+					recordId
 				);
-				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 = {
+				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,
-						...data,
-						...updatedRecord,
+						...autosavePost,
+						...record,
 					};
-					newRecord = Object.keys( newRecord ).reduce(
+					data = Object.keys( data ).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 ];
+								acc[ key ] = data[ 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
+						);
+					}
+				} 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,
-						newRecord,
+						updatedRecord,
 						undefined,
-						true
-					);
-				} else {
-					dispatch.receiveAutosaves(
-						persistedRecord.id,
-						updatedRecord
+						true,
+						edits
 					);
 				}
-			} 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
-				);
+			} catch ( _error ) {
+				hasError = true;
+				error = _error;
 			}
-		} catch ( _error ) {
-			hasError = true;
-			error = _error;
-		}
-		dispatch( {
-			type: 'SAVE_ENTITY_RECORD_FINISH',
-			kind,
-			name,
-			recordId,
-			error,
-			isAutosave,
-		} );
+			dispatch( {
+				type: 'SAVE_ENTITY_RECORD_FINISH',
+				kind,
+				name,
+				recordId,
+				error,
+				isAutosave,
+			} );
 
-		if ( hasError && throwOnError ) {
-			throw error;
-		}
+			if ( hasError && throwOnError ) {
+				throw error;
+			}
 
-		return updatedRecord;
-	} finally {
-		dispatch.__unstableReleaseStoreLock( lock );
-	}
-};
+			return updatedRecord;
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
+		}
+	};
 
 /**
  * Runs multiple core-data actions at the same time using one API request.
@@ -626,41 +643,43 @@ export const saveEntityRecord = (
  * @return {(thunkArgs: Object) => Promise} A promise that resolves to an array containing the return
  *                                          values of each function given in `requests`.
  */
-export const __experimentalBatch = ( requests ) => async ( { dispatch } ) => {
-	const 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,
-				} )
-			);
-		},
+export const __experimentalBatch =
+	( requests ) =>
+	async ( { dispatch } ) => {
+		const 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;
 	};
-	const resultPromises = requests.map( ( request ) => request( api ) );
-	const [ , ...results ] = await Promise.all( [
-		batch.run(),
-		...resultPromises,
-	] );
-	return results;
-};
 
 /**
  * Action triggered to save an entity record's edits.
@@ -670,30 +689,27 @@ export const __experimentalBatch = ( requests ) => async ( { dispatch } ) => {
  * @param {Object} recordId ID of the record.
  * @param {Object} options  Saving options.
  */
-export const saveEditedEntityRecord = (
-	kind,
-	name,
-	recordId,
-	options
-) => async ( { select, dispatch } ) => {
-	if ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {
-		return;
-	}
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, name } );
-	if ( ! entityConfig ) {
-		return;
-	}
-	const entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;
+export const saveEditedEntityRecord =
+	( kind, name, recordId, options ) =>
+	async ( { select, dispatch } ) => {
+		if ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {
+			return;
+		}
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, name } );
+		if ( ! entityConfig ) {
+			return;
+		}
+		const entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;
 
-	const edits = select.getEntityRecordNonTransientEdits(
-		kind,
-		name,
-		recordId
-	);
-	const record = { [ entityIdKey ]: recordId, ...edits };
-	return await dispatch.saveEntityRecord( kind, name, record, options );
-};
+		const edits = select.getEntityRecordNonTransientEdits(
+			kind,
+			name,
+			recordId
+		);
+		const record = { [ entityIdKey ]: recordId, ...edits };
+		return await dispatch.saveEntityRecord( kind, name, record, options );
+	};
 
 /**
  * Action triggered to save only specified properties for the entity.
@@ -704,29 +720,30 @@ export const saveEditedEntityRecord = (
  * @param {Array}  itemsToSave List of entity properties to save.
  * @param {Object} options     Saving options.
  */
-export const __experimentalSaveSpecifiedEntityEdits = (
-	kind,
-	name,
-	recordId,
-	itemsToSave,
-	options
-) => async ( { select, dispatch } ) => {
-	if ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {
-		return;
-	}
-	const edits = select.getEntityRecordNonTransientEdits(
-		kind,
-		name,
-		recordId
-	);
-	const editsToSave = {};
-	for ( const edit in edits ) {
-		if ( itemsToSave.some( ( item ) => item === edit ) ) {
-			editsToSave[ edit ] = edits[ edit ];
+export const __experimentalSaveSpecifiedEntityEdits =
+	( kind, name, recordId, itemsToSave, options ) =>
+	async ( { select, dispatch } ) => {
+		if ( ! select.hasEditsForEntityRecord( kind, name, recordId ) ) {
+			return;
 		}
-	}
-	return await dispatch.saveEntityRecord( kind, name, editsToSave, options );
-};
+		const edits = select.getEntityRecordNonTransientEdits(
+			kind,
+			name,
+			recordId
+		);
+		const editsToSave = {};
+		for ( const edit in edits ) {
+			if ( itemsToSave.some( ( item ) => item === edit ) ) {
+				editsToSave[ edit ] = edits[ edit ];
+			}
+		}
+		return await dispatch.saveEntityRecord(
+			kind,
+			name,
+			editsToSave,
+			options
+		);
+	};
 
 /**
  * Returns an action object used in signalling that Upload permissions have been received.