@wordpress/core-data 7.48.0 → 7.48.1

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/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

@@ -14,3 +14,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';

package/src/utils/save-crdt-doc.js

@@ -0,0 +1,64 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+/**
+ * Internal dependencies
+ */
+import { getSyncManager } from '../sync';
+
+const SYNC_SAVE_API_PATH = '/wp-sync/v1/save';
+const saveCRDTDocQueues = new Map();
+
+async function serializeAndSaveCRDTDoc( objectType, objectId, room ) {
+	const serializedDoc = await getSyncManager()?.createPersistedCRDTDoc(
+		objectType,
+		objectId
+	);
+
+	if ( ! serializedDoc ) {
+		return;
+	}
+
+	await apiFetch( {
+		path: SYNC_SAVE_API_PATH,
+		method: 'POST',
+		data: {
+			room,
+			doc: serializedDoc,
+		},
+	} );
+}
+
+/**
+ * Persist the current CRDT document through the sync /save endpoint.
+ *
+ * @param {import('@wordpress/sync').ObjectType} objectType Object type.
+ * @param {import('@wordpress/sync').ObjectID}   objectId   Object ID.
+ */
+export async function saveCRDTDoc( objectType, objectId ) {
+	const room = `${ objectType }:${ objectId }`;
+
+	// Saves are chained per-room, which forms a queue.
+	// Without a queue, two /save calls might fire close together with a risk
+	// that the older serialized CRDT snapshot completes after the newer one and
+	// overwrites it with stale data.
+	// Wait for the prior request chain to complete before firing the next save.
+	const previousSave = saveCRDTDocQueues.get( room ) || Promise.resolve();
+
+	const currentSave = previousSave
+		// A failed save should reject its caller, but not block later saves.
+		.catch( () => {} )
+		.then( () => serializeAndSaveCRDTDoc( objectType, objectId, room ) );
+
+	saveCRDTDocQueues.set( room, currentSave );
+
+	try {
+		await currentSave;
+	} finally {
+		if ( saveCRDTDocQueues.get( room ) === currentSave ) {
+			saveCRDTDocQueues.delete( room );
+		}
+	}
+}

package/src/utils/test/crdt-blocks.ts

@@ -196,7 +196,40 @@ describe( 'crdt-blocks', () => {
 			expect( content.toString() ).toBe( 'Updated content' );
 		} );
 
-		it( 'preserves the local clientId when an updated block arrives with a different clientId', () => {
+		it( 'updates the clientId when an updated block arrives with a different clientId', () => {
+			const initialBlocks: Block[] = [
+				{
+					name: 'core/paragraph',
+					attributes: { content: 'Initial content' },
+					innerBlocks: [],
+					clientId: 'initial-id',
+				},
+			];
+
+			mergeCrdtBlocks( yblocks, initialBlocks, null );
+			expect( yblocks.get( 0 ).get( 'clientId' ) ).toBe( 'initial-id' );
+
+			const updatedBlocks: Block[] = [
+				{
+					name: 'core/paragraph',
+					attributes: { content: 'Updated content' },
+					innerBlocks: [],
+					clientId: 'updated-id',
+				},
+			];
+
+			mergeCrdtBlocks( yblocks, updatedBlocks, null );
+
+			expect( yblocks.length ).toBe( 1 );
+			const block = yblocks.get( 0 );
+			expect( block.get( 'clientId' ) ).toBe( 'updated-id' );
+			const content = (
+				block.get( 'attributes' ) as YBlockAttributes
+			 ).get( 'content' ) as Y.Text;
+			expect( content.toString() ).toBe( 'Updated content' );
+		} );
+
+		it( 'preserves the local clientId when requested for reparsed content blocks', () => {
 			// Simulates the Code Editor flow: the sender re-parses raw HTML on
 			// every keystroke, which mints a fresh clientId for every block.
 			// The Y.Doc's clientId should stay stable so remote peers don't
@@ -222,7 +255,9 @@ describe( 'crdt-blocks', () => {
 				},
 			];
 
-			mergeCrdtBlocks( yblocks, reparsedBlocks, null );
+			mergeCrdtBlocks( yblocks, reparsedBlocks, null, {
+				preserveClientIds: true,
+			} );
 
 			expect( yblocks.length ).toBe( 1 );
 			const block = yblocks.get( 0 );
@@ -2867,6 +2902,26 @@ describe( 'crdt-blocks', () => {
 		} );
 	} );
 
+	describe( 'mergeRichTextUpdate - rapid typing', () => {
+		it( 'appends repeated text one character at a time with cursor hints', () => {
+			const text =
+				'987654321098765432109876543210987654321098765432109876543210';
+			const yText = doc.getText( 'test' );
+			yText.insert( 0, 'p1' );
+
+			for ( let i = 1; i <= text.length; i++ ) {
+				const value = `p1${ text.slice( 0, i ) }`;
+				mergeRichTextUpdate(
+					yText,
+					value,
+					asHtmlStringIndex( value.length )
+				);
+			}
+
+			expect( yText.toString() ).toBe( `p1${ text }` );
+		} );
+	} );
+
 	describe( 'supplementary plane characters (non-emoji)', () => {
 		// Characters above U+FFFF are stored as surrogate pairs in UTF-16,
 		// so .length === 2 per character. The diff library v8 counts them

package/src/utils/test/rtc-rich-text-cursor-scope.test.js

@@ -254,8 +254,8 @@ describe( 'RTC rich-text cursor scope bug', () => {
 				},
 				'LOCAL_EDITOR_ORIGIN'
 			);
-			// SyncManager.update is deferred through yieldToEventLoop.
-			// Wait one tick so the CRDT write has been applied before inspecting it.
+			// Selection history writes are deferred. Wait one tick before
+			// inspecting the document.
 			await waitForNextTick();
 		}
 

package/src/utils/test/save-crdt-doc.js

@@ -0,0 +1,185 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+/**
+ * Internal dependencies
+ */
+import { getSyncManager } from '../../sync';
+import { saveCRDTDoc } from '../save-crdt-doc';
+
+jest.mock( '@wordpress/api-fetch' );
+jest.mock( '../../sync', () => ( {
+	getSyncManager: jest.fn(),
+} ) );
+
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise( ( _resolve, _reject ) => {
+		resolve = _resolve;
+		reject = _reject;
+	} );
+
+	return { promise, resolve, reject };
+}
+
+async function flushPromises() {
+	await new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
+}
+
+describe( 'saveCRDTDoc', () => {
+	let syncManager;
+
+	beforeEach( () => {
+		apiFetch.mockReset();
+		syncManager = {
+			createPersistedCRDTDoc: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( syncManager );
+	} );
+
+	it( 'saves the serialized CRDT document through the sync endpoint', async () => {
+		const fetch = createDeferred();
+		syncManager.createPersistedCRDTDoc.mockResolvedValue( 'doc' );
+		apiFetch.mockImplementation( () => fetch.promise );
+
+		const save = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		fetch.resolve( {} );
+		await save;
+
+		expect( apiFetch ).toHaveBeenCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc',
+			},
+		} );
+	} );
+
+	it( 'does not call the sync endpoint when there is no serialized CRDT document', async () => {
+		syncManager.createPersistedCRDTDoc.mockResolvedValue( null );
+
+		await saveCRDTDoc( 'postType/post', 1 );
+
+		expect( apiFetch ).not.toHaveBeenCalled();
+	} );
+
+	it( 'serializes save requests for the same room', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc
+			.mockResolvedValueOnce( 'doc-1' )
+			.mockResolvedValueOnce( 'doc-2' );
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 1 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 1 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-1',
+			},
+		} );
+
+		firstFetch.resolve( {} );
+		await firstSave;
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+	} );
+
+	it( 'does not serialize save requests for different rooms', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc.mockImplementation(
+			( objectType, objectId ) => Promise.resolve( `doc-${ objectId }` )
+		);
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 2 );
+
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenNthCalledWith( 1, {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-1',
+			},
+		} );
+		expect( apiFetch ).toHaveBeenNthCalledWith( 2, {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:2',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+		firstFetch.resolve( {} );
+		await firstSave;
+	} );
+
+	it( 'continues a same-room queue after a failed save', async () => {
+		const firstFetch = createDeferred();
+		syncManager.createPersistedCRDTDoc
+			.mockResolvedValueOnce( 'doc-1' )
+			.mockResolvedValueOnce( 'doc-2' );
+		apiFetch
+			.mockImplementationOnce( () => firstFetch.promise )
+			.mockResolvedValueOnce( {} );
+
+		const firstSave = saveCRDTDoc( 'postType/post', 1 );
+		const secondSave = saveCRDTDoc( 'postType/post', 1 );
+
+		await flushPromises();
+
+		firstFetch.reject( new Error( 'save failed' ) );
+		await expect( firstSave ).rejects.toThrow( 'save failed' );
+		await flushPromises();
+
+		expect( syncManager.createPersistedCRDTDoc ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenCalledTimes( 2 );
+		expect( apiFetch ).toHaveBeenLastCalledWith( {
+			path: '/wp-sync/v1/save',
+			method: 'POST',
+			data: {
+				room: 'postType/post:1',
+				doc: 'doc-2',
+			},
+		} );
+
+		await secondSave;
+	} );
+} );