@wordpress/core-data 7.38.0 → 7.39.0

package/src/test/actions.js

@@ -18,6 +18,7 @@ import {
 	receiveCurrentUser,
 	__experimentalBatch,
 } from '../actions';
+import { getSyncManager } from '../sync';
 
 jest.mock( '../batch', () => {
 	const { createBatch } = jest.requireActual( '../batch' );
@@ -28,6 +29,11 @@ jest.mock( '../batch', () => {
 	};
 } );
 
+jest.mock( '../sync', () => ( {
+	getSyncManager: jest.fn(),
+	LOCAL_EDITOR_ORIGIN: 'local-editor',
+} ) );
+
 describe( 'editEntityRecord', () => {
 	it( 'throws when the edited entity does not have a loaded config.', async () => {
 		const entityConfig = {
@@ -50,6 +56,402 @@ describe( 'editEntityRecord', () => {
 		);
 		expect( select.getEntityConfig ).toHaveBeenCalledTimes( 1 );
 	} );
+
+	it( 'dispatches the correct action for non-merged edits', () => {
+		const dispatch = jest.fn();
+		const select = {
+			getEntityConfig: () => ( {
+				kind: 'postType',
+				name: 'post',
+				mergedEdits: {},
+			} ),
+			getRawEntityRecord: () => ( {
+				id: 1,
+				title: 'Original Title',
+				content: 'Original Content',
+			} ),
+			getEditedEntityRecord: () => ( {
+				id: 1,
+				title: 'Original Title',
+				content: 'Original Content',
+			} ),
+			getUndoManager: () => ( {
+				addRecord: jest.fn(),
+			} ),
+		};
+
+		editEntityRecord( 'postType', 'post', 1, { title: 'New Title' } )( {
+			select,
+			dispatch,
+		} );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'EDIT_ENTITY_RECORD',
+			kind: 'postType',
+			name: 'post',
+			recordId: 1,
+			edits: { title: 'New Title' },
+		} );
+	} );
+
+	it( 'merges edits for fields defined in mergedEdits config', () => {
+		const dispatch = jest.fn();
+		const select = {
+			getEntityConfig: () => ( {
+				kind: 'postType',
+				name: 'post',
+				mergedEdits: { meta: true },
+			} ),
+			getRawEntityRecord: () => ( {
+				id: 1,
+				meta: { existingKey: 'existingValue' },
+			} ),
+			getEditedEntityRecord: () => ( {
+				id: 1,
+				meta: {
+					existingKey: 'existingValue',
+					editedKey: 'editedValue',
+				},
+			} ),
+			getUndoManager: () => ( {
+				addRecord: jest.fn(),
+			} ),
+		};
+
+		editEntityRecord( 'postType', 'post', 1, {
+			meta: { newKey: 'newValue' },
+		} )( {
+			select,
+			dispatch,
+		} );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'EDIT_ENTITY_RECORD',
+			kind: 'postType',
+			name: 'post',
+			recordId: 1,
+			edits: {
+				meta: {
+					existingKey: 'existingValue',
+					editedKey: 'editedValue',
+					newKey: 'newValue',
+				},
+			},
+		} );
+	} );
+
+	it( 'handles both merged and non-merged edits together', () => {
+		const dispatch = jest.fn();
+		const select = {
+			getEntityConfig: () => ( {
+				kind: 'postType',
+				name: 'post',
+				mergedEdits: { meta: true },
+			} ),
+			getRawEntityRecord: () => ( {
+				id: 1,
+				title: 'Original Title',
+				meta: { existingKey: 'existingValue' },
+			} ),
+			getEditedEntityRecord: () => ( {
+				id: 1,
+				title: 'Original Title',
+				meta: { existingKey: 'existingValue' },
+			} ),
+			getUndoManager: () => ( {
+				addRecord: jest.fn(),
+			} ),
+		};
+
+		editEntityRecord( 'postType', 'post', 1, {
+			title: 'New Title',
+			meta: { newKey: 'newValue' },
+		} )( { select, dispatch } );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'EDIT_ENTITY_RECORD',
+			kind: 'postType',
+			name: 'post',
+			recordId: 1,
+			edits: {
+				title: 'New Title',
+				meta: {
+					existingKey: 'existingValue',
+					newKey: 'newValue',
+				},
+			},
+		} );
+	} );
+
+	it( 'clears edit when merged value equals persisted record', () => {
+		const dispatch = jest.fn();
+		const select = {
+			getEntityConfig: () => ( {
+				kind: 'postType',
+				name: 'post',
+				mergedEdits: { meta: true },
+			} ),
+			getRawEntityRecord: () => ( {
+				id: 1,
+				meta: { key1: 'value1', key2: 'value2' },
+			} ),
+			getEditedEntityRecord: () => ( {
+				id: 1,
+				meta: { key1: 'value1' },
+			} ),
+			getUndoManager: () => ( {
+				addRecord: jest.fn(),
+			} ),
+		};
+
+		// Editing meta to add key2 back should result in a value equal to the persisted record
+		editEntityRecord( 'postType', 'post', 1, {
+			meta: { key2: 'value2' },
+		} )( { select, dispatch } );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'EDIT_ENTITY_RECORD',
+			kind: 'postType',
+			name: 'post',
+			recordId: 1,
+			edits: {
+				// meta should be undefined because merged value equals persisted record
+				meta: undefined,
+			},
+		} );
+	} );
+
+	it( 'clears non-merged edit when value equals persisted record', () => {
+		const dispatch = jest.fn();
+		const select = {
+			getEntityConfig: () => ( {
+				kind: 'postType',
+				name: 'post',
+				mergedEdits: {},
+			} ),
+			getRawEntityRecord: () => ( {
+				id: 1,
+				title: 'Original Title',
+			} ),
+			getEditedEntityRecord: () => ( {
+				id: 1,
+				title: 'Edited Title',
+			} ),
+			getUndoManager: () => ( {
+				addRecord: jest.fn(),
+			} ),
+		};
+
+		// Editing title back to original should clear the edit
+		editEntityRecord( 'postType', 'post', 1, {
+			title: 'Original Title',
+		} )( { select, dispatch } );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'EDIT_ENTITY_RECORD',
+			kind: 'postType',
+			name: 'post',
+			recordId: 1,
+			edits: {
+				title: undefined,
+			},
+		} );
+	} );
+
+	describe( 'with SyncManager', () => {
+		let syncManager;
+
+		beforeEach( () => {
+			// Create a mock sync manager
+			syncManager = {
+				update: jest.fn(),
+			};
+			getSyncManager.mockReturnValue( syncManager );
+		} );
+
+		afterEach( () => {
+			getSyncManager.mockReset();
+		} );
+
+		it( 'passes merged edits to SyncManager#update for merged fields', () => {
+			const dispatch = jest.fn();
+			const select = {
+				getEntityConfig: () => ( {
+					kind: 'postType',
+					name: 'post',
+					mergedEdits: { meta: true },
+					syncConfig: {},
+				} ),
+				getRawEntityRecord: () => ( {
+					id: 1,
+					meta: { existingKey: 'existingValue' },
+				} ),
+				getEditedEntityRecord: () => ( {
+					id: 1,
+					meta: {
+						existingKey: 'existingValue',
+						editedKey: 'editedValue',
+					},
+				} ),
+				getUndoManager: () => ( {
+					addRecord: jest.fn(),
+				} ),
+			};
+
+			editEntityRecord( 'postType', 'post', 1, {
+				meta: { newKey: 'newValue' },
+			} )( {
+				select,
+				dispatch,
+			} );
+
+			// Verify SyncManager#update was called with merged edits
+			expect( syncManager.update ).toHaveBeenCalledWith(
+				'postType/post',
+				1,
+				{
+					meta: {
+						existingKey: 'existingValue',
+						editedKey: 'editedValue',
+						newKey: 'newValue',
+					},
+				},
+				'local-editor',
+				{ isNewUndoLevel: true }
+			);
+		} );
+
+		it( 'passes merged edits to SyncManager#update even when value equals persisted record', () => {
+			const dispatch = jest.fn();
+			const select = {
+				getEntityConfig: () => ( {
+					kind: 'postType',
+					name: 'post',
+					mergedEdits: { meta: true },
+					syncConfig: {},
+				} ),
+				getRawEntityRecord: () => ( {
+					id: 1,
+					meta: { key1: 'value1', key2: 'value2' },
+				} ),
+				getEditedEntityRecord: () => ( {
+					id: 1,
+					meta: { key1: 'value1' },
+				} ),
+				getUndoManager: () => ( {
+					addRecord: jest.fn(),
+				} ),
+			};
+
+			// Editing meta to add key2 back results in a value equal to the persisted record
+			editEntityRecord( 'postType', 'post', 1, {
+				meta: { key2: 'value2' },
+			} )( { select, dispatch } );
+
+			// Verify SyncManager#update was called with merged edits (not cleaned/undefined)
+			expect( syncManager.update ).toHaveBeenCalledWith(
+				'postType/post',
+				1,
+				{
+					meta: {
+						key1: 'value1',
+						key2: 'value2',
+					},
+				},
+				'local-editor',
+				{ isNewUndoLevel: true }
+			);
+
+			// But the local store dispatch should still receive undefined for the cleaned edit
+			expect( dispatch ).toHaveBeenCalledWith( {
+				type: 'EDIT_ENTITY_RECORD',
+				kind: 'postType',
+				name: 'post',
+				recordId: 1,
+				edits: {
+					meta: undefined,
+				},
+			} );
+		} );
+
+		it( 'passes merged and non-merged edits correctly to SyncManager#update', () => {
+			const dispatch = jest.fn();
+			const select = {
+				getEntityConfig: () => ( {
+					kind: 'postType',
+					name: 'post',
+					mergedEdits: { meta: true },
+					syncConfig: {},
+				} ),
+				getRawEntityRecord: () => ( {
+					id: 1,
+					title: 'Original Title',
+					meta: { existingKey: 'existingValue' },
+				} ),
+				getEditedEntityRecord: () => ( {
+					id: 1,
+					title: 'Original Title',
+					meta: { existingKey: 'existingValue' },
+				} ),
+				getUndoManager: () => ( {
+					addRecord: jest.fn(),
+				} ),
+			};
+
+			editEntityRecord( 'postType', 'post', 1, {
+				title: 'New Title',
+				meta: { newKey: 'newValue' },
+			} )( { select, dispatch } );
+
+			// Verify SyncManager#update was called with merged meta but non-merged title
+			expect( syncManager.update ).toHaveBeenCalledWith(
+				'postType/post',
+				1,
+				{
+					title: 'New Title',
+					meta: {
+						existingKey: 'existingValue',
+						newKey: 'newValue',
+					},
+				},
+				'local-editor',
+				{ isNewUndoLevel: true }
+			);
+		} );
+
+		it( 'does not call SyncManager#update when syncConfig is not defined', () => {
+			const dispatch = jest.fn();
+			const select = {
+				getEntityConfig: () => ( {
+					kind: 'postType',
+					name: 'post',
+					mergedEdits: { meta: true },
+					// No syncConfig
+				} ),
+				getRawEntityRecord: () => ( {
+					id: 1,
+					meta: { existingKey: 'existingValue' },
+				} ),
+				getEditedEntityRecord: () => ( {
+					id: 1,
+					meta: { existingKey: 'existingValue' },
+				} ),
+				getUndoManager: () => ( {
+					addRecord: jest.fn(),
+				} ),
+			};
+
+			editEntityRecord( 'postType', 'post', 1, {
+				meta: { newKey: 'newValue' },
+			} )( {
+				select,
+				dispatch,
+			} );
+
+			// Verify SyncManager#update was NOT called
+			expect( syncManager.update ).not.toHaveBeenCalled();
+		} );
+	} );
 } );
 
 describe( 'deleteEntityRecord', () => {

package/src/test/entity-provider.js

@@ -86,6 +86,7 @@ describe( 'useEntityBlockEditor', () => {
 		const edit = ( { children } ) => <>{ children }</>;
 
 		registerBlockType( 'core/test-block', {
+			apiVersion: 3,
 			supports: {
 				className: false,
 			},
@@ -112,6 +113,7 @@ describe( 'useEntityBlockEditor', () => {
 		} );
 
 		registerBlockType( 'core/test-block-with-array-of-strings', {
+			apiVersion: 3,
 			supports: {
 				className: false,
 			},

package/src/test/resolvers.js

@@ -168,9 +168,11 @@ describe( 'getEntityRecord', () => {
 			1,
 			POST_RECORD,
 			{
+				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
+				restoreUndoMeta: expect.any( Function ),
 				saveRecord: expect.any( Function ),
 			}
 		);
@@ -221,9 +223,11 @@ describe( 'getEntityRecord', () => {
 			1,
 			{ ...POST_RECORD, foo: 'bar' },
 			{
+				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
+				restoreUndoMeta: expect.any( Function ),
 				saveRecord: expect.any( Function ),
 			}
 		);

package/src/types.ts

@@ -2,11 +2,20 @@ export interface AnyFunction {
 	( ...args: any[] ): any;
 }
 
-// Avoid a circular dependency with @wordpress/editor
+/**
+ * Avoid a circular dependency with @wordpress/editor
+ *
+ * Additionaly, this type marks `attributeKey` and `offset` as possibly
+ * `undefined`, which can happen in two known scenarios:
+ *
+ * 1. If a user has an entire block highlighted (e.g., a `core/image` block).
+ * 2. If there's an intermediate selection state while inserting a block, those
+ *    properties will be temporarily`undefined`.
+ */
 export interface WPBlockSelection {
 	clientId: string;
-	attributeKey: string;
-	offset: number;
+	attributeKey?: string;
+	offset?: number;
 }
 
 export interface WPSelection {

package/src/utils/block-selection-history.ts

@@ -0,0 +1,176 @@
+/**
+ * External dependencies
+ */
+/**
+ * WordPress dependencies
+ */
+import { Y } from '@wordpress/sync';
+
+/**
+ * Internal dependencies
+ */
+import { findBlockByClientIdInDoc } from './crdt-utils';
+import type { WPBlockSelection, WPSelection } from '../types';
+
+// Default size for selection history (not including current selection)
+const SELECTION_HISTORY_DEFAULT_SIZE = 5;
+
+export enum YSelectionType {
+	RelativeSelection = 'RelativeSelection',
+	BlockSelection = 'BlockSelection',
+}
+
+export interface YRelativeSelection {
+	type: YSelectionType.RelativeSelection;
+	attributeKey: string;
+	relativePosition: Y.RelativePosition;
+	clientId: string;
+	offset: number;
+}
+
+export interface YBlockSelection {
+	type: YSelectionType.BlockSelection;
+	clientId: string;
+}
+
+export type YSelection = YRelativeSelection | YBlockSelection;
+
+export type YFullSelection = {
+	start: YSelection;
+	end: YSelection;
+};
+
+export interface YSelectionHistory {
+	selection: YFullSelection;
+	backupSelections?: YFullSelection[];
+}
+
+export interface BlockSelectionHistory {
+	getSelectionHistory: () => YFullSelection[];
+	updateSelection: ( newSelection: WPSelection ) => void;
+}
+
+/**
+ * This function is used to track recent block selections to help in restoring
+ * a user's selection after an undo or redo operation.
+ *
+ * Maintains a history array for previous selections, which can be used for
+ * backup restoration locations.
+ * @param ydoc
+ * @param historySize
+ */
+export function createBlockSelectionHistory(
+	ydoc: Y.Doc,
+	historySize: number = SELECTION_HISTORY_DEFAULT_SIZE
+): BlockSelectionHistory {
+	let history: YFullSelection[] = [];
+
+	/**
+	 * Get the block history including current selection.
+	 */
+	const getSelectionHistory = (): YFullSelection[] => {
+		return history.slice( 0 );
+	};
+
+	/**
+	 * Update the selection history with a new selection.
+	 * @param newSelection
+	 */
+	const updateSelection = ( newSelection: WPSelection ): void => {
+		if (
+			! newSelection?.selectionStart?.clientId ||
+			! newSelection?.selectionEnd?.clientId
+		) {
+			return;
+		}
+
+		const { selectionStart, selectionEnd } = newSelection;
+		const start = convertWPBlockSelectionToSelection(
+			selectionStart,
+			ydoc
+		);
+		const end = convertWPBlockSelectionToSelection( selectionEnd, ydoc );
+
+		addToHistory( { start, end } );
+	};
+
+	/**
+	 * Add a selection to the history, maintaining only the last `historySize` unique selections.
+	 * New selections are added to the front.
+	 * Removes any existing entries with the same start and end block combination.
+	 * @param yFullSelection
+	 */
+	const addToHistory = ( yFullSelection: YFullSelection ): void => {
+		// Remove any existing entries with the same start and end block combination
+		const startClientId = yFullSelection.start.clientId;
+		const endClientId = yFullSelection.end.clientId;
+
+		history = history.filter( ( entry ) => {
+			const isSameBlockCombination =
+				entry.start.clientId === startClientId &&
+				entry.end.clientId === endClientId;
+
+			return ! isSameBlockCombination;
+		} );
+
+		// Add the new selection to the front
+		history.unshift( yFullSelection );
+
+		// Trim to max size (remove oldest entries from the back)
+		if ( history.length > historySize + 1 ) {
+			history = history.slice( 0, historySize + 1 );
+		}
+	};
+
+	return {
+		getSelectionHistory,
+		updateSelection,
+	};
+}
+
+/**
+ * Convert a WPBlockSelection to a YSelection.
+ * @param selection
+ * @param ydoc
+ * @return A YSelection object.
+ */
+function convertWPBlockSelectionToSelection(
+	selection: WPBlockSelection,
+	ydoc: Y.Doc
+): YSelection {
+	const clientId = selection.clientId;
+	const block = findBlockByClientIdInDoc( clientId, ydoc );
+	const attributes = block?.get( 'attributes' );
+	const attributeKey = selection.attributeKey;
+
+	const changedYText = attributeKey
+		? attributes?.get( attributeKey )
+		: undefined;
+
+	const isYText = changedYText instanceof Y.Text;
+	const isFullyDefinedSelection = attributeKey && clientId;
+
+	if ( ! isYText || ! isFullyDefinedSelection ) {
+		// We either don't have a valid YText (it's been deleted) or we've
+		// been passed a selection that's just a block clientId.
+		// Store as BlockSelection.
+		return {
+			type: YSelectionType.BlockSelection,
+			clientId,
+		};
+	}
+
+	const offset = selection.offset ?? 0;
+	const relativePosition = Y.createRelativePositionFromTypeIndex(
+		changedYText,
+		offset
+	);
+
+	return {
+		type: YSelectionType.RelativeSelection,
+		attributeKey,
+		relativePosition,
+		clientId,
+		offset,
+	};
+}