@wordpress/core-data 7.41.2-next.v.202603102151.0 → 7.42.0

package/src/test/resolvers.js

@@ -172,16 +172,69 @@ describe( 'getEntityRecord', () => {
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
+				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
 				restoreUndoMeta: expect.any( Function ),
-				saveRecord: expect.any( Function ),
 			}
 		);
 	} );
 
-	it( 'saveRecord fetches edited record and saves full entity record', async () => {
-		const POST_RECORD = { id: 1, title: 'Test Post' };
-		const EDITED_RECORD = { id: 1, title: 'Edited Post' };
+	it( 'persistCRDTDoc fetches edited record and does not save full entity record 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 = {
+			json: () => Promise.resolve( ENTITY_RECORD ),
+		};
+		const ENTITIES_WITH_SYNC = [
+			{
+				name: 'bar',
+				kind: 'foo',
+				baseURL: '/wp/v2/foo',
+				baseURLParams: { context: 'edit' },
+				syncConfig: {},
+			},
+		];
+
+		dispatch.saveEntityRecord = jest.fn();
+
+		const resolveSelectWithSync = {
+			getEntitiesConfig: jest.fn( () => ENTITIES_WITH_SYNC ),
+			getEditedEntityRecord: jest.fn( () =>
+				Promise.resolve( EDITED_RECORD )
+			),
+		};
+
+		triggerFetch.mockImplementation( () => ENTITY_RESPONSE );
+
+		await getEntityRecord(
+			'foo',
+			'bar',
+			1
+		)( {
+			dispatch,
+			registry,
+			resolveSelect: resolveSelectWithSync,
+		} );
+
+		// Extract the handlers passed to syncManager.load.
+		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
+
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
+		await resolveSelectWithSync.getEditedEntityRecord();
+
+		// Should have fetched the full edited entity record.
+		expect(
+			resolveSelectWithSync.getEditedEntityRecord
+		).toHaveBeenCalledWith( 'foo', 'bar', 1 );
+
+		// Should not have called saveEntityRecord.
+		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
+	} );
+
+	it( 'persistCRDTDoc fetches edited record and saves full entity record', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
+		const EDITED_RECORD = { id: 1, title: 'Edited Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
 		};
@@ -219,8 +272,8 @@ describe( 'getEntityRecord', () => {
 		// Extract the handlers passed to syncManager.load.
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		// Call saveRecord and wait for the internal promise chain.
-		handlers.saveRecord();
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
 		await resolveSelectWithSync.getEditedEntityRecord();
 
 		// Should have fetched the full edited entity record.
@@ -236,8 +289,8 @@ describe( 'getEntityRecord', () => {
 		);
 	} );
 
-	it( 'saveRecord saves even when there are no unsaved edits', async () => {
-		const POST_RECORD = { id: 1, title: 'Test Post' };
+	it( 'persistCRDTDoc saves even when there are no unsaved edits', async () => {
+		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
 		};
@@ -275,8 +328,8 @@ describe( 'getEntityRecord', () => {
 
 		const handlers = syncManager.load.mock.calls[ 0 ][ 4 ];
 
-		// Call saveRecord and wait for the internal promise chain.
-		handlers.saveRecord();
+		// Call persistCRDTDoc and wait for the internal promise chain.
+		handlers.persistCRDTDoc();
 		await resolveSelectWithSync.getEditedEntityRecord();
 
 		// Should save the record even with no edits (the whole point of the fix).
@@ -336,9 +389,9 @@ describe( 'getEntityRecord', () => {
 				editRecord: expect.any( Function ),
 				getEditedRecord: expect.any( Function ),
 				onStatusChange: expect.any( Function ),
+				persistCRDTDoc: expect.any( Function ),
 				refetchRecord: expect.any( Function ),
 				restoreUndoMeta: expect.any( Function ),
-				saveRecord: expect.any( Function ),
 			}
 		);
 	} );

package/src/test/selectors.js

@@ -23,6 +23,7 @@ import {
 	getCurrentUser,
 	getRevisions,
 	getRevision,
+	hasRevision,
 } from '../selectors';
 
 describe( 'getEntityRecord', () => {
@@ -1215,3 +1216,152 @@ describe( 'getRevision', () => {
 		} );
 	} );
 } );
+
+describe( 'hasRevision', () => {
+	it( 'returns false if revision has not been received', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							revisions: {
+								1: {
+									items: {},
+									itemIsComplete: {},
+									queries: {},
+								},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect( hasRevision( state, 'postType', 'post', 1, 10 ) ).toBe( false );
+	} );
+
+	it( 'returns false if parent record does not exist', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {},
+			},
+		} );
+		expect( hasRevision( state, 'postType', 'post', 1, 10 ) ).toBe( false );
+	} );
+
+	it( 'returns true when full revision exists and no fields query', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							revisions: {
+								1: {
+									items: {
+										default: {
+											10: {
+												id: 10,
+												content: 'chicken',
+												parent: 1,
+											},
+										},
+									},
+									itemIsComplete: {
+										default: {
+											10: true,
+										},
+									},
+									queries: {},
+								},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect( hasRevision( state, 'postType', 'post', 1, 10 ) ).toBe( true );
+	} );
+
+	it( 'returns true when requested fields exist on the revision', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							revisions: {
+								1: {
+									items: {
+										default: {
+											10: {
+												id: 10,
+												content: 'chicken',
+												title: { raw: 'egg' },
+												parent: 1,
+											},
+										},
+									},
+									itemIsComplete: {
+										default: {
+											10: true,
+										},
+									},
+									queries: {},
+								},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect(
+			hasRevision( state, 'postType', 'post', 1, 10, {
+				_fields: [ 'id', 'content' ],
+			} )
+		).toBe( true );
+		expect(
+			hasRevision( state, 'postType', 'post', 1, 10, {
+				_fields: [ 'id', 'title.raw' ],
+			} )
+		).toBe( true );
+	} );
+
+	it( 'returns false when requested fields are missing', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							revisions: {
+								1: {
+									items: {
+										default: {
+											10: {
+												id: 10,
+												parent: 1,
+											},
+										},
+									},
+									itemIsComplete: {
+										default: {
+											10: true,
+										},
+									},
+									queries: {},
+								},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect(
+			hasRevision( state, 'postType', 'post', 1, 10, {
+				_fields: [ 'id', 'content' ],
+			} )
+		).toBe( false );
+		expect(
+			hasRevision( state, 'postType', 'post', 1, 10, {
+				_fields: [ 'id', 'title.raw' ],
+			} )
+		).toBe( false );
+	} );
+} );

package/src/test/store.js

@@ -36,6 +36,10 @@ function createTestRegistry() {
 		__unstable_rest_base: 'posts',
 		supportsPagination: true,
 		revisionKey: 'id',
+		getRevisionsUrl: ( parentId, revisionId ) =>
+			`/wp/v2/posts/${ parentId }/revisions${
+				revisionId ? '/' + revisionId : ''
+			}`,
 	};
 
 	// Add the post entity to the store
@@ -258,3 +262,65 @@ describe( 'clearEntityRecordEdits', () => {
 		).toEqual( select.getRawEntityRecord( 'postType', 'post', post.id ) );
 	} );
 } );
+
+describe( 'getRevisions', () => {
+	const KIND = 'postType';
+	const NAME = 'post';
+	const RECORD_KEY = 1;
+	const REVISIONS = [ { id: 2 }, { id: 3 }, { id: 4 } ];
+
+	let registry;
+
+	beforeEach( () => {
+		registry = createTestRegistry();
+		triggerFetch.mockReset();
+	} );
+
+	it( 'preserves all revisions when getRevision resolves after getRevisions', async () => {
+		let resolveSlowFetch;
+		const slowFetchPromise = new Promise( ( resolve ) => {
+			resolveSlowFetch = resolve;
+		} );
+
+		triggerFetch.mockImplementation( ( { path } ) => {
+			if ( path && path.includes( 'revisions' ) ) {
+				// Single revision fetch: return slow promise.
+				if ( /revisions\/\d+/.test( path ) ) {
+					return slowFetchPromise;
+				}
+				// Collection fetch: return immediately.
+				return Promise.resolve( {
+					json: () => Promise.resolve( REVISIONS ),
+					headers: { get: () => String( REVISIONS.length ) },
+				} );
+			}
+			return Promise.resolve( {} );
+		} );
+
+		const resolveSelectStore = registry.resolveSelect( coreDataStore );
+
+		// Start getRevision first (slow), then getRevisions (fast).
+		const revisionPromise = resolveSelectStore.getRevision(
+			KIND,
+			NAME,
+			RECORD_KEY,
+			1,
+			{ context: 'edit' }
+		);
+		await resolveSelectStore.getRevisions( KIND, NAME, RECORD_KEY, {
+			context: 'edit',
+		} );
+
+		// Now resolve the slow single-revision fetch.
+		resolveSlowFetch( REVISIONS[ 0 ] );
+		await revisionPromise;
+
+		// Wait for all pending thunks (receiveRevisions) to settle.
+		await new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
+
+		const allRevisions = registry
+			.select( coreDataStore )
+			.getRevisions( KIND, NAME, RECORD_KEY, { context: 'edit' } );
+		expect( allRevisions.map( ( r ) => r.id ) ).toEqual( [ 2, 3, 4 ] );
+	} );
+} );

package/src/types.ts

@@ -1,13 +1,19 @@
 /**
  * WordPress dependencies
  */
-import type { Y } from '@wordpress/sync';
+import type { ConnectionStatusDisconnected, Y } from '@wordpress/sync';
 
 /**
  * Internal dependencies
  */
 import type { SelectionType } from './utils/crdt-user-selections';
 
+export type { ConnectionStatus } from '@wordpress/sync';
+
+export type ConnectionError = NonNullable<
+	ConnectionStatusDisconnected[ 'error' ]
+>;
+
 export interface AnyFunction {
 	( ...args: any[] ): any;
 }
@@ -66,6 +72,16 @@ export type CursorPosition = {
 	absoluteOffset: number;
 };
 
+/**
+ * The direction of a text selection, indicating where the caret sits.
+ */
+export enum SelectionDirection {
+	/** The caret is at the end of the selection (default / left-to-right). */
+	Forward = 'f',
+	/** The caret is at the start of the selection (right-to-left). */
+	Backward = 'b',
+}
+
 export type SelectionNone = {
 	// The user has not made a selection.
 	type: SelectionType.None;
@@ -86,6 +102,8 @@ export type SelectionInOneBlock = {
 	type: SelectionType.SelectionInOneBlock;
 	cursorStartPosition: CursorPosition;
 	cursorEndPosition: CursorPosition;
+	// The direction of the selection, indicating where the caret sits.
+	selectionDirection?: SelectionDirection;
 };
 
 export type SelectionInMultipleBlocks = {
@@ -95,6 +113,8 @@ export type SelectionInMultipleBlocks = {
 	type: SelectionType.SelectionInMultipleBlocks;
 	cursorStartPosition: CursorPosition;
 	cursorEndPosition: CursorPosition;
+	// The direction of the selection, indicating where the caret sits.
+	selectionDirection?: SelectionDirection;
 };
 
 export type SelectionWholeBlock = {
@@ -111,3 +131,8 @@ export type SelectionState =
 	| SelectionInOneBlock
 	| SelectionInMultipleBlocks
 	| SelectionWholeBlock;
+
+export interface ResolvedSelection {
+	richTextOffset: number | null;
+	localClientId: string | null;
+}

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

@@ -9,7 +9,10 @@ import { Y } from '@wordpress/sync';
 /**
  * Internal dependencies
  */
-import { findBlockByClientIdInDoc } from './crdt-utils';
+import {
+	findBlockByClientIdInDoc,
+	richTextOffsetToHtmlIndex,
+} from './crdt-utils';
 import type { WPBlockSelection, WPSelection } from '../types';
 
 // Default size for selection history (not including current selection)
@@ -163,7 +166,7 @@ function convertWPBlockSelectionToSelection(
 	const offset = selection.offset ?? 0;
 	const relativePosition = Y.createRelativePositionFromTypeIndex(
 		changedYText,
-		offset
+		richTextOffsetToHtmlIndex( changedYText.toString(), offset )
 	);
 
 	return {

package/src/utils/crdt-blocks.ts

@@ -62,6 +62,37 @@ export type YBlockAttributes = Y.Map< Y.Text | unknown >;
 
 const serializableBlocksCache = new WeakMap< WeakKey, Block[] >();
 
+/**
+ * Recursively walk an attribute value and convert any RichTextData instances
+ * to their string (HTML) representation. This is necessary for array-type and
+ * object-type attributes, which can contain nested RichTextData.
+ *
+ * @param value The attribute value to serialize.
+ * @return The value with all RichTextData instances replaced by strings.
+ */
+function serializeAttributeValue( value: unknown ): unknown {
+	if ( value instanceof RichTextData ) {
+		return value.valueOf();
+	}
+
+	// e.g. core/table `body`: [ { cells: [ { content: RichTextData } ] } ]
+	if ( Array.isArray( value ) ) {
+		return value.map( serializeAttributeValue );
+	}
+
+	// e.g. a single row inside core/table `body`: { cells: [ ... ] }
+	if ( value && typeof value === 'object' ) {
+		const result: Record< string, unknown > = {};
+
+		for ( const [ k, v ] of Object.entries( value ) ) {
+			result[ k ] = serializeAttributeValue( v );
+		}
+		return result;
+	}
+
+	return value;
+}
+
 function makeBlockAttributesSerializable(
 	blockName: string,
 	attributes: BlockAttributes
@@ -73,9 +104,7 @@ function makeBlockAttributesSerializable(
 			continue;
 		}
 
-		if ( value instanceof RichTextData ) {
-			newAttributes[ key ] = value.valueOf();
-		}
+		newAttributes[ key ] = serializeAttributeValue( value );
 	}
 	return newAttributes;
 }

package/src/utils/crdt-selection.ts

@@ -18,7 +18,10 @@ import {
 	type YFullSelection,
 	type YSelection,
 } from './block-selection-history';
-import { findBlockByClientIdInDoc } from './crdt-utils';
+import {
+	findBlockByClientIdInDoc,
+	htmlIndexToRichTextOffset,
+} from './crdt-utils';
 import type { WPBlockSelection, WPSelection } from '../types';
 
 // WeakMap to store BlockSelectionHistory instances per Y.Doc
@@ -74,7 +77,10 @@ function convertYSelectionToBlockSelection(
 			return {
 				clientId,
 				attributeKey,
-				offset: absolutePosition.index,
+				offset: htmlIndexToRichTextOffset(
+					absolutePosition.type.toString(),
+					absolutePosition.index
+				),
 			};
 		}
 	} else if ( ySelection.type === YSelectionType.BlockSelection ) {

package/src/utils/crdt-user-selections.ts

@@ -12,7 +12,7 @@ import { store as blockEditorStore } from '@wordpress/block-editor';
 import { CRDT_RECORD_MAP_KEY } from '../sync';
 import type { YPostRecord } from './crdt';
 import type { YBlock, YBlocks } from './crdt-blocks';
-import { getRootMap } from './crdt-utils';
+import { getRootMap, richTextOffsetToHtmlIndex } from './crdt-utils';
 import type {
 	AbsoluteBlockIndexPath,
 	WPBlockSelection,
@@ -22,6 +22,7 @@ import type {
 	SelectionInOneBlock,
 	SelectionInMultipleBlocks,
 	SelectionWholeBlock,
+	SelectionDirection,
 	CursorPosition,
 } from '../types';
 
@@ -44,16 +45,20 @@ export enum SelectionType {
  * differ between the block-editor store and the Yjs document (e.g. in "Show
  * Template" mode).
  *
- * @param selectionStart - The start position of the selection
- * @param selectionEnd   - The end position of the selection
- * @param yDoc           - The Yjs document
+ * @param selectionStart             - The start position of the selection
+ * @param selectionEnd               - The end position of the selection
+ * @param yDoc                       - The Yjs document
+ * @param options                    - Optional parameters
+ * @param options.selectionDirection - The direction of the selection (forward or backward)
  * @return The SelectionState
  */
 export function getSelectionState(
 	selectionStart: WPBlockSelection,
 	selectionEnd: WPBlockSelection,
-	yDoc: Y.Doc
+	yDoc: Y.Doc,
+	options?: { selectionDirection?: SelectionDirection }
 ): SelectionState {
+	const { selectionDirection } = options ?? {};
 	const ymap = getRootMap< YPostRecord >( yDoc, CRDT_RECORD_MAP_KEY );
 	const yBlocks = ymap.get( 'blocks' );
 
@@ -122,6 +127,7 @@ export function getSelectionState(
 			type: SelectionType.SelectionInOneBlock,
 			cursorStartPosition,
 			cursorEndPosition,
+			selectionDirection,
 		};
 	}
 
@@ -137,6 +143,7 @@ export function getSelectionState(
 		type: SelectionType.SelectionInMultipleBlocks,
 		cursorStartPosition,
 		cursorEndPosition,
+		selectionDirection,
 	};
 }
 
@@ -171,7 +178,7 @@ function getCursorPosition(
 
 	const relativePosition = Y.createRelativePositionFromTypeIndex(
 		currentYText,
-		selection.offset
+		richTextOffsetToHtmlIndex( currentYText.toString(), selection.offset )
 	);
 
 	return {
@@ -315,7 +322,9 @@ export function areSelectionsStatesEqual(
 				areCursorPositionsEqual(
 					selection1.cursorEndPosition,
 					( selection2 as SelectionInOneBlock ).cursorEndPosition
-				)
+				) &&
+				selection1.selectionDirection ===
+					( selection2 as SelectionInOneBlock ).selectionDirection
 			);
 
 		case SelectionType.SelectionInMultipleBlocks:
@@ -329,7 +338,10 @@ export function areSelectionsStatesEqual(
 					selection1.cursorEndPosition,
 					( selection2 as SelectionInMultipleBlocks )
 						.cursorEndPosition
-				)
+				) &&
+				selection1.selectionDirection ===
+					( selection2 as SelectionInMultipleBlocks )
+						.selectionDirection
 			);
 		case SelectionType.WholeBlock:
 			return Y.compareRelativePositions(