@wordpress/core-data 7.41.0 → 7.41.2-next.v.202603161435.0

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
@@ -113,6 +117,122 @@ describe( 'getEntityRecord', () => {
 	} );
 } );
 
+describe( 'getEntityRecords', () => {
+	const POSTS = [
+		createTestPost( 1 ),
+		createTestPost( 2 ),
+		createTestPost( 3 ),
+	];
+
+	let registry;
+
+	beforeEach( () => {
+		registry = createTestRegistry();
+		triggerFetch.mockReset();
+	} );
+
+	it( 'preserves collection when getEntityRecord resolves after getEntityRecords', async () => {
+		let resolveSlowFetch;
+		const slowFetchPromise = new Promise( ( resolve ) => {
+			resolveSlowFetch = resolve;
+		} );
+
+		triggerFetch.mockImplementation( ( { path } ) => {
+			// Single post fetch (e.g. /wp/v2/posts/1): return slow promise.
+			if ( /\/wp\/v2\/posts\/\d+/.test( path ) ) {
+				return slowFetchPromise;
+			}
+			// Collection fetch: return immediately.
+			return Promise.resolve( {
+				json: () => Promise.resolve( POSTS ),
+				headers: {
+					get: ( header ) => {
+						if ( header === 'X-WP-Total' ) {
+							return String( POSTS.length );
+						}
+						if ( header === 'X-WP-TotalPages' ) {
+							return '1';
+						}
+						return null;
+					},
+				},
+			} );
+		} );
+
+		const resolveSelectStore = registry.resolveSelect( coreDataStore );
+
+		// Start getEntityRecord first (slow), then getEntityRecords (fast).
+		const singlePromise = resolveSelectStore.getEntityRecord(
+			'postType',
+			'post',
+			1,
+			{ context: 'edit' }
+		);
+		await resolveSelectStore.getEntityRecords( 'postType', 'post', {
+			context: 'edit',
+		} );
+
+		// Now resolve the slow single-record fetch.
+		resolveSlowFetch( {
+			json: () => Promise.resolve( POSTS[ 0 ] ),
+			headers: { get: () => null },
+		} );
+		await singlePromise;
+
+		// Wait for all pending thunks to settle.
+		await new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
+
+		const allPosts = registry
+			.select( coreDataStore )
+			.getEntityRecords( 'postType', 'post', { context: 'edit' } );
+		expect( allPosts.map( ( p ) => p.id ) ).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'preserves collection when getEntityRecord is called after getEntityRecords', async () => {
+		triggerFetch.mockImplementation( ( { path } ) => {
+			// Collection fetch.
+			if ( ! /\/wp\/v2\/posts\/\d+/.test( path ) ) {
+				return Promise.resolve( {
+					json: () => Promise.resolve( POSTS ),
+					headers: {
+						get: ( header ) => {
+							if ( header === 'X-WP-Total' ) {
+								return String( POSTS.length );
+							}
+							if ( header === 'X-WP-TotalPages' ) {
+								return '1';
+							}
+							return null;
+						},
+					},
+				} );
+			}
+			// Single post fetch.
+			return Promise.resolve( {
+				json: () => Promise.resolve( POSTS[ 0 ] ),
+				headers: { get: () => null },
+			} );
+		} );
+
+		const resolveSelectStore = registry.resolveSelect( coreDataStore );
+
+		// First resolve the collection.
+		await resolveSelectStore.getEntityRecords( 'postType', 'post', {
+			context: 'edit',
+		} );
+
+		// Then resolve a single record.
+		await resolveSelectStore.getEntityRecord( 'postType', 'post', 1, {
+			context: 'edit',
+		} );
+
+		const allPosts = registry
+			.select( coreDataStore )
+			.getEntityRecords( 'postType', 'post', { context: 'edit' } );
+		expect( allPosts.map( ( p ) => p.id ) ).toEqual( [ 1, 2, 3 ] );
+	} );
+} );
+
 describe( 'clearEntityRecordEdits', () => {
 	let registry;
 
@@ -142,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

@@ -66,6 +66,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 +96,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 +107,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 +125,8 @@ export type SelectionState =
 	| SelectionInOneBlock
 	| SelectionInMultipleBlocks
 	| SelectionWholeBlock;
+
+export interface ResolvedSelection {
+	textIndex: number | null;
+	localClientId: string | null;
+}

package/src/utils/crdt-blocks.ts

@@ -22,9 +22,14 @@ interface BlockAttributes {
 	[ key: string ]: unknown;
 }
 
+interface BlockAttributeType {
+	role?: string;
+	type?: string;
+}
+
 interface BlockType {
+	attributes?: Record< string, BlockAttributeType >;
 	name: string;
-	attributes?: Record< string, { type?: string } >;
 }
 
 // A block as represented in Gutenberg's data store.
@@ -58,10 +63,16 @@ export type YBlockAttributes = Y.Map< Y.Text | unknown >;
 const serializableBlocksCache = new WeakMap< WeakKey, Block[] >();
 
 function makeBlockAttributesSerializable(
+	blockName: string,
 	attributes: BlockAttributes
 ): BlockAttributes {
 	const newAttributes = { ...attributes };
 	for ( const [ key, value ] of Object.entries( attributes ) ) {
+		if ( isLocalAttribute( blockName, key ) ) {
+			delete newAttributes[ key ];
+			continue;
+		}
+
 		if ( value instanceof RichTextData ) {
 			newAttributes[ key ] = value.valueOf();
 		}
@@ -76,7 +87,7 @@ function makeBlocksSerializable( blocks: Block[] ): Block[] {
 		return {
 			...rest,
 			name,
-			attributes: makeBlockAttributesSerializable( attributes ),
+			attributes: makeBlockAttributesSerializable( name, attributes ),
 			innerBlocks: makeBlocksSerializable( innerBlocks ),
 		};
 	} );
@@ -202,12 +213,7 @@ export function mergeCrdtBlocks(
 			makeBlocksSerializable( incomingBlocks )
 		);
 	}
-	const allBlocks = serializableBlocksCache.get( incomingBlocks ) ?? [];
-
-	// Ensure we skip blocks that we don't want to sync at the moment
-	const blocksToSync = allBlocks.filter( ( block ) =>
-		shouldBlockBeSynced( block )
-	);
+	const blocksToSync = serializableBlocksCache.get( incomingBlocks ) ?? [];
 
 	// This is a rudimentary diff implementation similar to the y-prosemirror diffing
 	// approach.
@@ -382,32 +388,6 @@ export function mergeCrdtBlocks(
 	}
 }
 
-/**
- * Determine if a block should be synced.
- *
- * Ex: A gallery block should not be synced until the images have been
- * uploaded to WordPress, and their url is available. Before that,
- * it's not possible to access the blobs on a client as those are
- * local.
- *
- * @param block The block to check.
- * @return True if the block should be synced, false otherwise.
- */
-function shouldBlockBeSynced( block: Block ): boolean {
-	// Verify that the gallery block is ready to be synced.
-	// This means that, all images have had their blobs converted to full URLs.
-	// Checking for only the blobs ensures that blocks that have just been inserted work as well.
-	if ( 'core/gallery' === block.name ) {
-		return ! block.innerBlocks.some(
-			( innerBlock ) =>
-				innerBlock.attributes && innerBlock.attributes.blob
-		);
-	}
-
-	// Allow all other blocks to be synced.
-	return true;
-}
-
 /**
  * Update a single attribute on a Yjs block attributes map (currentAttributes).
  *
@@ -448,38 +428,35 @@ function updateYBlockAttribute(
 	}
 }
 
-// Cached types for block attributes.
-let cachedBlockAttributeTypes: Map< string, Map< string, string > >;
+// Cached block attribute types, populated once from getBlockTypes().
+let cachedBlockAttributeTypes: Map< string, Map< string, BlockAttributeType > >;
 
 /**
- * Get the defined attribute type for a block attribute.
+ * Get the attribute type definition for a block attribute.
  *
  * @param blockName     The name of the block, e.g. 'core/paragraph'.
  * @param attributeName The name of the attribute, e.g. 'content'.
- * @return The type of the attribute, e.g. 'rich-text' or 'string'.
+ * @return The type definition of the attribute.
  */
 function getBlockAttributeType(
 	blockName: string,
 	attributeName: string
-): string | undefined {
+): BlockAttributeType | undefined {
 	if ( ! cachedBlockAttributeTypes ) {
 		// Parse the attributes for all blocks once.
-		cachedBlockAttributeTypes = new Map< string, Map< string, string > >();
+		cachedBlockAttributeTypes = new Map();
 
 		for ( const blockType of getBlockTypes() as BlockType[] ) {
-			const blockAttributeTypeMap = new Map< string, string >();
-
-			for ( const [ name, definition ] of Object.entries(
-				blockType.attributes ?? {}
-			) ) {
-				if ( definition.type ) {
-					blockAttributeTypeMap.set( name, definition.type );
-				}
-			}
-
 			cachedBlockAttributeTypes.set(
 				blockType.name,
-				blockAttributeTypeMap
+				new Map< string, BlockAttributeType >(
+					Object.entries( blockType.attributes ?? {} ).map(
+						( [ name, definition ] ) => {
+							const { role, type } = definition;
+							return [ name, { role, type } ];
+						}
+					)
+				)
 			);
 		}
 	}
@@ -503,11 +480,13 @@ function isExpectedAttributeType(
 	const expectedAttributeType = getBlockAttributeType(
 		blockName,
 		attributeName
-	);
+	)?.type;
 
 	if ( expectedAttributeType === 'rich-text' ) {
 		return attributeValue instanceof Y.Text;
-	} else if ( expectedAttributeType === 'string' ) {
+	}
+
+	if ( expectedAttributeType === 'string' ) {
 		return typeof attributeValue === 'string';
 	}
 
@@ -515,6 +494,18 @@ function isExpectedAttributeType(
 	return true;
 }
 
+/**
+ * Given a block name and attribute key, return true if the attribute is local
+ * and should not be synced.
+ *
+ * @param blockName     The name of the block, e.g. 'core/image'.
+ * @param attributeName The name of the attribute to check, e.g. 'blob'.
+ * @return True if the attribute is local, false otherwise.
+ */
+function isLocalAttribute( blockName: string, attributeName: string ): boolean {
+	return 'local' === getBlockAttributeType( blockName, attributeName )?.role;
+}
+
 /**
  * Given a block name and attribute key, return true if the attribute is rich-text typed.
  *
@@ -526,7 +517,9 @@ function isRichTextAttribute(
 	blockName: string,
 	attributeName: string
 ): boolean {
-	return 'rich-text' === getBlockAttributeType( blockName, attributeName );
+	return (
+		'rich-text' === getBlockAttributeType( blockName, attributeName )?.type
+	);
 }
 
 let localDoc: Y.Doc;

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

@@ -13,16 +13,17 @@ 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 type {
-	AbsoluteBlockIndexPath,
-	WPBlockSelection,
-	SelectionState,
-	SelectionNone,
-	SelectionCursor,
-	SelectionInOneBlock,
-	SelectionInMultipleBlocks,
-	SelectionWholeBlock,
-	CursorPosition,
+import type { SelectionDirection } from '../types';
+import {
+	type AbsoluteBlockIndexPath,
+	type WPBlockSelection,
+	type SelectionState,
+	type SelectionNone,
+	type SelectionCursor,
+	type SelectionInOneBlock,
+	type SelectionInMultipleBlocks,
+	type SelectionWholeBlock,
+	type 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,
 	};
 }
 
@@ -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(

package/src/utils/crdt.ts

@@ -342,8 +342,6 @@ export function getPostChangesFromCRDTDoc(
 						);
 					}
 
-					// The consumers of blocks have memoization that renders optimization
-					// here unnecessary.
 					return true;
 				}
 
@@ -351,11 +349,8 @@ export function getPostChangesFromCRDTDoc(
 					// Do not overwrite a "floating" date. Borrowing logic from the
 					// isEditedPostDateFloating selector.
 					const currentDateIsFloating =
-						[ 'draft', 'auto-draft', 'pending' ].includes(
-							ymap.get( 'status' ) as string
-						) &&
-						( null === currentValue ||
-							editedRecord.modified === currentValue );
+						null === currentValue ||
+						editedRecord.modified === currentValue;
 
 					if ( currentDateIsFloating ) {
 						return false;

package/src/utils/index.js

@@ -15,3 +15,4 @@ export {
 	ALLOWED_RESOURCE_ACTIONS,
 } from './user-permissions';
 export { RECEIVE_INTERMEDIATE_RESULTS } from './receive-intermediate-results';
+export { default as normalizeQueryForResolution } from './normalize-query-for-resolution';