@wordpress/core-data 7.48.0 → 7.48.2-next.v.202606191442.0

package/src/test/reducer.js

@@ -12,6 +12,8 @@ import {
 	userPermissions,
 	autosaves,
 	currentUser,
+	syncUndoManagerState,
+	undoManager,
 } from '../reducer';
 
 describe( 'entities', () => {
@@ -531,3 +533,45 @@ describe( 'currentUser', () => {
 		expect( state ).toEqual( currentUserData );
 	} );
 } );
+
+describe( 'undoManager', () => {
+	it( 'returns the same reference for unrelated actions', () => {
+		const originalState = undoManager( undefined, {} );
+		const state = undoManager( originalState, {
+			type: 'UNRELATED',
+		} );
+
+		expect( state ).toBe( originalState );
+	} );
+} );
+
+describe( 'syncUndoManagerState', () => {
+	it( 'stores sync undo manager availability', () => {
+		const state = syncUndoManagerState( undefined, {
+			type: 'SYNC_UNDO_MANAGER_CHANGE',
+			hasRedo: false,
+			hasUndo: true,
+		} );
+
+		expect( state ).toEqual( {
+			hasRedo: false,
+			hasUndo: true,
+		} );
+	} );
+
+	it( 'updates sync undo manager availability', () => {
+		const state = syncUndoManagerState(
+			{ hasRedo: false, hasUndo: true },
+			{
+				type: 'SYNC_UNDO_MANAGER_CHANGE',
+				hasRedo: true,
+				hasUndo: false,
+			}
+		);
+
+		expect( state ).toEqual( {
+			hasRedo: true,
+			hasUndo: false,
+		} );
+	} );
+} );

package/src/test/resolvers.js

@@ -25,7 +25,6 @@ import {
 	getAutosaves,
 	getCurrentUser,
 } from '../resolvers';
-import { saveEntityRecord } from '../actions';
 import { RECEIVE_INTERMEDIATE_RESULTS } from '../utils';
 
 describe( 'getEntityRecord', () => {
@@ -50,6 +49,7 @@ describe( 'getEntityRecord', () => {
 			receiveEntityRecords: jest.fn(),
 			__unstableAcquireStoreLock: jest.fn(),
 			__unstableReleaseStoreLock: jest.fn(),
+			__unstableNotifySyncUndoManagerChange: jest.fn(),
 			receiveUserPermissions: jest.fn(),
 			finishResolutions: jest.fn(),
 		} );
@@ -57,6 +57,7 @@ describe( 'getEntityRecord', () => {
 
 		syncManager = {
 			load: jest.fn(),
+			update: jest.fn(),
 		};
 		getSyncManager.mockImplementation( () => syncManager );
 	} );
@@ -173,6 +174,7 @@ describe( 'getEntityRecord', () => {
 				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
+				onUndoStackChange: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
 				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
@@ -181,7 +183,48 @@ describe( 'getEntityRecord', () => {
 		);
 	} );
 
-	it( 'persistCRDTDoc fetches edited record and does not save full entity record when the entity does not support meta', async () => {
+	it( 'notifies core-data when the sync undo manager stack changes', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post' };
+		const POST_RESPONSE = {
+			json: () => Promise.resolve( POST_RECORD ),
+		};
+		const ENTITIES_WITH_SYNC = [
+			{
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
+				baseURLParams: { context: 'edit' },
+				syncConfig: {},
+			},
+		];
+
+		const resolveSelectWithSync = {
+			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
+			getEditedEntityRecord: jest.fn(),
+		};
+
+		triggerFetch.mockImplementation( () => POST_RESPONSE );
+
+		await getEntityRecord(
+			'postType',
+			'post',
+			1
+		)( {
+			dispatch,
+			registry,
+			resolveSelect: resolveSelectWithSync,
+		} );
+
+		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
+
+		handlers.onUndoStackChange( { hasRedo: false, hasUndo: true } );
+
+		expect(
+			dispatch.__unstableNotifySyncUndoManagerChange
+		).toHaveBeenCalledWith( { hasRedo: false, hasUndo: true } );
+	} );
+
+	it( 'persistCRDTDoc fetches edited post record and does not save when the entity does not support meta', async () => {
 		const ENTITY_RECORD = { id: 1, title: 'Test Record' };
 		const EDITED_RECORD = { id: 1, title: 'Edited Record' };
 		const ENTITY_RESPONSE = {
@@ -189,15 +232,16 @@ describe( 'getEntityRecord', () => {
 		};
 		const ENTITIES_WITH_SYNC = [
 			{
-				name: 'bar',
-				kind: 'foo',
-				baseURL: '/wp/v2/foo',
+				name: 'post',
+				kind: 'postType',
+				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn();
 
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
@@ -209,8 +253,8 @@ describe( 'getEntityRecord', () => {
 		triggerFetch.mockImplementation( () => ENTITY_RESPONSE );
 
 		await getEntityRecord(
-			'foo',
-			'bar',
+			'postType',
+			'post',
 			1
 		)( {
 			dispatch,
@@ -222,19 +266,20 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
 		// Should have fetched the full edited entity record.
 		expect(
 			resolveSelectWithSync.getEditedEntityRecord
-		).toHaveBeenCalledWith( 'foo', 'bar', 1 );
+		).toHaveBeenCalledWith( 'postType', 'post', 1 );
 
 		// Should not have called saveEntityRecord.
 		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+		expect( syncManager.createPersistedCRDTDoc ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc saves only the entity ID and omits REST-invalid fields', async () => {
+	it( 'persistCRDTDoc saves post CRDT docs through the sync endpoint', async () => {
+		const SERIALIZED_DOC = 'serialized-crdt-doc';
 		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const EDITED_RECORD = {
 			id: 1,
@@ -251,11 +296,14 @@ describe( 'getEntityRecord', () => {
 				kind: 'postType',
 				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn( () =>
+			Promise.resolve( SERIALIZED_DOC )
+		);
 
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
@@ -264,7 +312,9 @@ describe( 'getEntityRecord', () => {
 			),
 		};
 
-		triggerFetch.mockImplementation( () => POST_RESPONSE );
+		triggerFetch
+			.mockImplementationOnce( () => POST_RESPONSE )
+			.mockImplementationOnce( () => [] );
 
 		await getEntityRecord(
 			'postType',
@@ -280,25 +330,31 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
 		// Should have fetched the full edited entity record.
 		expect(
 			resolveSelectWithSync.getEditedEntityRecord
 		).toHaveBeenCalledWith( 'postType', 'post', 1 );
 
-		// Should only send the entity ID. The pre-persist hook creates the
-		// persisted CRDT meta without round-tripping the full edited record.
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledWith(
+			'postType/post',
+			1
 		);
+		expect( triggerFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: SERIALIZED_DOC,
+			},
+		} );
+		expect( syncManager.update ).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc saves even when there are no unsaved edits', async () => {
+	it( 'persistCRDTDoc persists post CRDT docs even when there are no unsaved edits', async () => {
+		const SERIALIZED_DOC = 'serialized-crdt-doc';
 		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
@@ -309,11 +365,14 @@ describe( 'getEntityRecord', () => {
 				kind: 'postType',
 				baseURL: '/wp/v2/posts',
 				baseURLParams: { context: 'edit' },
-				syncConfig: {},
+				syncConfig: { supportsPersistence: true },
 			},
 		];
 
 		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn( () =>
+			Promise.resolve( SERIALIZED_DOC )
+		);
 
 		// Return the same record (no edits) from getEditedEntityRecord.
 		const resolveSelectWithSync = {
@@ -323,7 +382,9 @@ describe( 'getEntityRecord', () => {
 			),
 		};
 
-		triggerFetch.mockImplementation( () => POST_RESPONSE );
+		triggerFetch
+			.mockImplementationOnce( () => POST_RESPONSE )
+			.mockImplementationOnce( () => [] );
 
 		await getEntityRecord(
 			'postType',
@@ -338,95 +399,55 @@ describe( 'getEntityRecord', () => {
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
 		// Call persistCRDTDoc and wait for the internal promise chain.
-		handlers.persistCRDTDoc();
-		await resolveSelectWithSync.getEditedEntityRecord();
+		await handlers.persistCRDTDoc();
 
-		// Should save only the entity ID even with no edits.
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
-		);
+		expect( triggerFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: SERIALIZED_DOC,
+			},
+		} );
+		expect( syncManager.update ).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc does not replay a stale save response into the sync document', async () => {
-		const INITIAL_TITLE = 'Initial Title';
-		const SYNCED_TITLE = 'Synced Title';
-		const POST_RECORD = { id: 1, title: INITIAL_TITLE, meta: {} };
-		const EDITED_RECORD = { id: 1, title: SYNCED_TITLE, meta: {} };
-		const STALE_SAVE_RESPONSE = {
+	it( 'persistCRDTDoc does not persist entities whose sync config does not support persistence', async () => {
+		const TERM_RECORD = { id: 1, name: 'Category', meta: {} };
+		const EDITED_RECORD = {
 			id: 1,
-			title: INITIAL_TITLE,
-			meta: { _crdt_document: 'serialized-crdt-doc' },
-		};
-		const liveSyncState = {
-			isSaved: false,
-			title: SYNCED_TITLE,
+			name: 'Edited Category',
+			description: '',
+			meta: {},
 		};
-		const POST_RESPONSE = {
-			json: () => Promise.resolve( POST_RECORD ),
+		const TERM_RESPONSE = {
+			json: () => Promise.resolve( TERM_RECORD ),
 		};
 		const ENTITIES_WITH_SYNC = [
 			{
-				name: 'post',
-				kind: 'postType',
-				baseURL: '/wp/v2/posts',
+				name: 'category',
+				kind: 'taxonomy',
+				baseURL: '/wp/v2/categories',
 				baseURLParams: { context: 'edit' },
 				syncConfig: {},
-				__unstablePrePersist: jest.fn( async () => ( {
-					meta: { _crdt_document: 'serialized-crdt-doc' },
-				} ) ),
 			},
 		];
 
-		const select = {
-			getEditedEntityRecord: jest.fn( () => EDITED_RECORD ),
-			getRawEntityRecord: jest.fn( () => POST_RECORD ),
-		};
 		const resolveSelectWithSync = {
 			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
 			getEditedEntityRecord: jest.fn( () =>
 				Promise.resolve( EDITED_RECORD )
 			),
 		};
-		let savePromise;
-
-		syncManager.update = jest.fn(
-			( _objectType, _objectId, changes, _origin, options ) => {
-				if (
-					Object.prototype.hasOwnProperty.call( changes, 'title' )
-				) {
-					liveSyncState.title = changes.title;
-				}
-				if ( options?.isSave ) {
-					liveSyncState.isSaved = true;
-				}
-			}
-		);
-		dispatch.saveEntityRecord = jest.fn(
-			( kind, name, record, options ) => {
-				savePromise = saveEntityRecord(
-					kind,
-					name,
-					record,
-					options
-				)( {
-					select,
-					dispatch,
-					resolveSelect: resolveSelectWithSync,
-				} );
-				return savePromise;
-			}
-		);
+		dispatch.saveEntityRecord = jest.fn();
+		syncManager.createPersistedCRDTDoc = jest.fn();
 
-		triggerFetch
-			.mockImplementationOnce( () => POST_RESPONSE )
-			.mockImplementationOnce( () => STALE_SAVE_RESPONSE );
+		triggerFetch.mockImplementation( () => TERM_RESPONSE );
 
 		await getEntityRecord(
-			'postType',
-			'post',
+			'taxonomy',
+			'category',
 			1
 		)( {
 			dispatch,
@@ -436,27 +457,13 @@ describe( 'getEntityRecord', () => {
 
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		handlers.persistCRDTDoc();
-		await Promise.resolve();
-		await savePromise;
+		await handlers.persistCRDTDoc();
 
-		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
-			'postType',
-			'post',
-			{ id: 1 },
-			{ __unstableSkipSyncUpdate: true }
-		);
-		expect( syncManager.update ).toHaveBeenCalledWith(
-			'postType/post',
-			1,
-			{},
-			'local-undo-ignored',
-			{ isSave: true }
-		);
-		expect( liveSyncState ).toEqual( {
-			isSaved: true,
-			title: SYNCED_TITLE,
-		} );
+		expect(
+			resolveSelectWithSync.getEditedEntityRecord
+		).not.toHaveBeenCalled();
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+		expect( syncManager.createPersistedCRDTDoc ).not.toHaveBeenCalled();
 	} );
 
 	it( 'provides transient properties when read/write config is supplied', async () => {
@@ -507,6 +514,7 @@ describe( 'getEntityRecord', () => {
 				addUndoMeta: expect.any( Function ),
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
+				onUndoStackChange: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
 				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),

package/src/test/selectors.js

@@ -24,7 +24,55 @@ import {
 	getRevisions,
 	getRevision,
 	hasRevision,
+	hasUndo,
+	hasRedo,
 } from '../selectors';
+import { getSyncManager } from '../sync';
+
+jest.mock( '../sync', () => ( {
+	getSyncManager: jest.fn(),
+} ) );
+
+describe( 'hasUndo/hasRedo', () => {
+	afterEach( () => {
+		getSyncManager.mockReset();
+	} );
+
+	it( 'reads undo availability from core-data state when a sync undo manager is available', () => {
+		const undoManager = {
+			hasUndo: jest.fn( () => false ),
+			hasRedo: jest.fn( () => false ),
+		};
+		getSyncManager.mockReturnValue( { undoManager } );
+
+		const state = deepFreeze( {
+			syncUndoManagerState: {
+				hasRedo: true,
+				hasUndo: true,
+			},
+		} );
+
+		expect( hasUndo( state ) ).toBe( true );
+		expect( hasRedo( state ) ).toBe( true );
+		expect( undoManager.hasUndo ).not.toHaveBeenCalled();
+		expect( undoManager.hasRedo ).not.toHaveBeenCalled();
+	} );
+
+	it( 'falls back to the default undo manager when no sync undo manager is available', () => {
+		const undoManager = {
+			hasUndo: jest.fn( () => true ),
+			hasRedo: jest.fn( () => false ),
+		};
+		getSyncManager.mockReturnValue( undefined );
+
+		const state = { undoManager };
+
+		expect( hasUndo( state ) ).toBe( true );
+		expect( hasRedo( state ) ).toBe( false );
+		expect( undoManager.hasUndo ).toHaveBeenCalled();
+		expect( undoManager.hasRedo ).toHaveBeenCalled();
+	} );
+} );
 
 describe( 'getEntityRecord', () => {
 	describe( 'normalizing Post ID passed as recordKey', () => {

package/src/utils/clear-unchanged-edits.ts

@@ -0,0 +1,34 @@
+/**
+ * External dependencies
+ */
+import fastDeepEqual from 'fast-deep-equal/es6/index.js';
+
+/**
+ * Returns a copy of `edits` where any value equal to its persisted counterpart
+ * is set to `undefined`. The edits reducer treats `undefined` as a signal to
+ * drop the edit, so the property is no longer considered dirty.
+ *
+ * @param edits           Edits keyed by property name.
+ * @param persistedRecord Persisted entity record to compare against.
+ *
+ * @return Edits with unchanged properties set to `undefined`.
+ */
+export default function clearUnchangedEdits(
+	edits: Record< string, unknown >,
+	persistedRecord: Record< string, any > | undefined
+): Record< string, unknown > {
+	if ( ! persistedRecord ) {
+		return edits;
+	}
+
+	return Object.fromEntries(
+		Object.entries( edits ).map( ( [ key, value ] ) => {
+			const persisted =
+				persistedRecord[ key ]?.raw ?? persistedRecord[ key ];
+			return [
+				key,
+				fastDeepEqual( value, persisted ) ? undefined : value,
+			];
+		} )
+	);
+}

package/src/utils/crdt-blocks.ts

@@ -69,6 +69,10 @@ export type YBlocks = Y.Array< YBlock >;
 // Attribute values will be typed as the union of `Y.Text` and `unknown`.
 export type YBlockAttributes = Y.Map< Y.Text | unknown >;
 
+interface MergeCrdtBlocksOptions {
+	preserveClientIds?: boolean;
+}
+
 /**
  * Optional description of where a cursor falls.
  *
@@ -420,11 +424,13 @@ function createNewYBlock( block: Block ): YBlock {
  * @param attributeCursor When provided, describes a selection cursor falling within a
  *                        RichText field associated with a specific block and attribute.
  *                        Derived from the changes that produced the blocks.
+ * @param options         Optional settings for the merge operation.
  */
 export function mergeCrdtBlocks(
 	yblocks: YBlocks,
 	incomingBlocks: Block[],
-	attributeCursor: MergeCursorPosition
+	attributeCursor: MergeCursorPosition,
+	options: MergeCrdtBlocksOptions = {}
 ): void {
 	// Ensure we are working with serializable block data.
 	if ( ! serializableBlocksCache.has( incomingBlocks ) ) {
@@ -594,32 +600,31 @@ export function mergeCrdtBlocks(
 						mergeCrdtBlocks(
 							yInnerBlocks,
 							incomingBlockPropertyValue ?? [],
-							attributeCursor
+							attributeCursor,
+							options
 						);
 						break;
 					}
 
 					case 'clientId': {
-						// Never overwrite the local block's clientId with the
-						// incoming one. Some callers (e.g. the Code Editor flow
-						// that parses raw HTML into blocks on every keystroke)
-						// produce randomized clientIds for blocks whose content
-						// has changed on every sync. Without this case the default
-						// branch would replace the stable Y.Doc clientId with
-						// a new one, causing remote peers to remount the block
-						// and flash the block's content on reload.
-						//
-						// This mirrors the clientId exclusion in `areBlocksEqual`.
-						// Convergence is preserved. Because we're not writing
-						// to the clientId, Yjs doesn't send an update to peers
-						// telling them to change the clientId, so everyone
-						// sees the same clientId per block.
-						// Inserts still use a new clientId via createNewYBlock,
-						// and the duplicate-clientId sweep below catches any
-						// edge cases. The clientId is anchored to the
-						// slot in the array rather than to specific content,
-						// which is consistent with areBlocksEqual ignoring
-						// clientId when diffing.
+						// Code Editor changes reparse raw HTML on every
+						// keystroke and regenerate fresh clientIds. Keep Y.Doc
+						// clientIds stable for the code editor so peers do not
+						// remount unchanged blocks on every edit.
+						if ( options.preserveClientIds ) {
+							break;
+						}
+
+						// Otherwise, accept new clientIds from updates
+						if (
+							incomingBlockPropertyValue !==
+							localYBlock.get( incomingBlockProperty )
+						) {
+							localYBlock.set(
+								incomingBlockProperty,
+								incomingBlockPropertyValue
+							);
+						}
 						break;
 					}
 

package/src/utils/crdt.ts

@@ -317,7 +317,8 @@ function mergeContentWithoutBlocks(
 	mergeCrdtBlocks(
 		currentBlocks,
 		parse( rawContent ) as Block[],
-		cursorPosition
+		cursorPosition,
+		{ preserveClientIds: true }
 	);
 }
 

package/src/utils/index.js

@@ -1,3 +1,4 @@
+export { default as clearUnchangedEdits } from './clear-unchanged-edits';
 export { default as conservativeMapItem } from './conservative-map-item';
 export { default as getNormalizedCommaSeparable } from './get-normalized-comma-separable';
 export { default as ifMatchingAction } from './if-matching-action';
@@ -14,3 +15,4 @@ export {
 } from './user-permissions';
 export { RECEIVE_INTERMEDIATE_RESULTS } from './receive-intermediate-results';
 export { default as normalizeQueryForResolution } from './normalize-query-for-resolution';
+export { saveCRDTDoc } from './save-crdt-doc';