@wordpress/core-data 7.42.0 → 7.43.2-next.v.202604091042.0

package/src/selectors.ts

@@ -20,7 +20,6 @@ import { DEFAULT_ENTITY_KEY } from './entities';
 import { getUndoManager } from './private-selectors';
 import {
 	getNormalizedCommaSeparable,
-	isRawAttribute,
 	setNestedValue,
 	isNumericID,
 	getUserPermissionCacheKey,
@@ -55,6 +54,7 @@ export interface State {
 	editorAssets: Record< string, any > | null;
 	syncConnectionStatuses?: Record< string, ConnectionStatus >;
 	collaborationSupported: boolean;
+	viewConfigs: Record< string, Record< string, any > >;
 }
 
 type EntityRecordKey = string | number;
@@ -523,25 +523,26 @@ export const getRawEntityRecord = createSelector(
 			name,
 			key
 		);
-		return (
-			record &&
-			Object.keys( record ).reduce( ( accumulator, _key ) => {
-				if (
-					isRawAttribute( getEntityConfig( state, kind, name ), _key )
-				) {
-					// Because edits are the "raw" attribute values,
-					// we return those from record selectors to make rendering,
-					// comparisons, and joins with edits easier.
-					accumulator[ _key ] =
-						record[ _key ]?.raw !== undefined
-							? record[ _key ]?.raw
-							: record[ _key ];
-				} else {
-					accumulator[ _key ] = record[ _key ];
+		const config = getEntityConfig( state, kind, name );
+		if ( ! record || ! config?.rawAttributes?.length ) {
+			return record;
+		}
+
+		// Because edits are the "raw" attribute values,
+		// we return those from record selectors to make rendering,
+		// comparisons, and joins with edits easier.
+		return Object.fromEntries(
+			Object.keys( record ).map( ( _key ) => {
+				if ( config.rawAttributes.includes( _key ) ) {
+					const rawValue = record[ _key ]?.raw;
+					return [
+						_key,
+						rawValue !== undefined ? rawValue : record[ _key ],
+					];
 				}
-				return accumulator;
-			}, {} as any )
-		);
+				return [ _key, record[ _key ] ];
+			} )
+		) as EntityRecord;
 	},
 	(
 		state: State,
@@ -654,7 +655,10 @@ export const getEntityRecords = ( <
 	if ( ! queriedState ) {
 		return null;
 	}
-	return getQueriedItems( queriedState, query );
+	return getQueriedItems( queriedState, query, {
+		supportsPagination: !! getEntityConfig( state, kind, name )
+			?.supportsPagination,
+	} );
 } ) as GetEntityRecords;
 
 /**
@@ -712,7 +716,10 @@ export const getEntityRecordsTotalPages = (
 	if ( ! queriedState ) {
 		return null;
 	}
-	if ( query?.per_page === -1 ) {
+	if (
+		! getEntityConfig( state, kind, name )?.supportsPagination ||
+		query?.per_page === -1
+	) {
 		return 1;
 	}
 	const totalItems = getQueriedTotalItems( queriedState, query );

package/src/utils/crdt-blocks.ts

@@ -16,19 +16,21 @@ import { Y } from '@wordpress/sync';
  * Internal dependencies
  */
 import { createYMap, type YMapRecord, type YMapWrap } from './crdt-utils';
+import { getCachedRichTextData } from './crdt-text';
 import { Delta } from '../sync';
 
 interface BlockAttributes {
 	[ key: string ]: unknown;
 }
 
-interface BlockAttributeType {
+interface BlockAttributeSchema {
 	role?: string;
 	type?: string;
+	query?: Record< string, BlockAttributeSchema >;
 }
 
 interface BlockType {
-	attributes?: Record< string, BlockAttributeType >;
+	attributes?: Record< string, BlockAttributeSchema >;
 	name: string;
 }
 
@@ -122,6 +124,85 @@ function makeBlocksSerializable( blocks: Block[] ): Block[] {
 	} );
 }
 
+/**
+ * Recursively walk an attribute value and convert any strings that correspond
+ * to rich-text schema nodes into RichTextData instances. This is the inverse
+ * of serializeAttributeValue and handles nested structures like table cells.
+ *
+ * @param schema The attribute type definition for this value.
+ * @param value  The attribute value from CRDT (toJSON).
+ * @return The value with rich-text strings replaced by RichTextData.
+ */
+function deserializeAttributeValue(
+	schema: BlockAttributeSchema | undefined,
+	value: unknown
+): unknown {
+	if ( schema?.type === 'rich-text' && typeof value === 'string' ) {
+		return getCachedRichTextData( value );
+	}
+
+	// e.g. core/table `body`: [ { cells: [ { content: RichTextData } ] } ]
+	if ( Array.isArray( value ) ) {
+		return value.map( ( item ) =>
+			deserializeAttributeValue( schema, item )
+		);
+	}
+
+	// e.g. a single row inside core/table `body`: { cells: [ ... ] }
+	if ( value && typeof value === 'object' ) {
+		const result: Record< string, unknown > = {};
+
+		for ( const [ key, innerValue ] of Object.entries(
+			value as Record< string, unknown >
+		) ) {
+			result[ key ] = deserializeAttributeValue(
+				schema?.query?.[ key ],
+				innerValue
+			);
+		}
+
+		return result;
+	}
+
+	return value;
+}
+
+/**
+ * Convert blocks from their CRDT-serialized form back to the runtime form
+ * expected by the block editor. Rich-text attributes are stored as Y.Text in
+ * the CRDT document, which serializes to plain strings via toJSON(). This
+ * function restores them to RichTextData instances so that block edit
+ * components that rely on RichTextData methods (e.g. `.text`) work correctly.
+ *
+ * @param blocks Blocks as extracted from the CRDT document via toJSON().
+ * @return Blocks with rich-text attributes restored to RichTextData.
+ */
+export function deserializeBlockAttributes( blocks: Block[] ): Block[] {
+	return blocks.map( ( block: Block ) => {
+		const { name, innerBlocks, attributes, ...rest } = block;
+
+		const newAttributes = { ...attributes };
+
+		for ( const [ key, value ] of Object.entries( attributes ) ) {
+			const schema = getBlockAttributeSchema( name, key );
+
+			if ( schema ) {
+				newAttributes[ key ] = deserializeAttributeValue(
+					schema,
+					value
+				);
+			}
+		}
+
+		return {
+			...rest,
+			name,
+			attributes: newAttributes,
+			innerBlocks: deserializeBlockAttributes( innerBlocks ?? [] ),
+		};
+	} );
+}
+
 /**
  * @param {any}   gblock
  * @param {Y.Map} yblock
@@ -174,14 +255,89 @@ function createNewYAttributeValue(
 	blockName: string,
 	attributeName: string,
 	attributeValue: unknown
-): Y.Text | unknown {
-	const isRichText = isRichTextAttribute( blockName, attributeName );
+): Y.Text | Y.Array< unknown > | Y.Map< unknown > | unknown {
+	const schema = getBlockAttributeSchema( blockName, attributeName );
+	return createYValueFromSchema( schema, attributeValue );
+}
+
+/**
+ * Recursively create the appropriate Y.js type for a value based on its
+ * block-attribute schema.
+ *
+ * - `rich-text`          -> Y.Text
+ * - `array`  with query  -> Y.Array of Y.Maps
+ * - `object` with query  -> Y.Map
+ * - anything else        -> plain value (unchanged)
+ *
+ * @param schema The attribute type definition.
+ * @param value  The plain JS value to convert.
+ * @return A Y.js type or the original value.
+ */
+function createYValueFromSchema(
+	schema: BlockAttributeSchema | undefined,
+	value: unknown
+): Y.Text | Y.Array< unknown > | Y.Map< unknown > | unknown {
+	if ( ! schema ) {
+		return value;
+	}
+
+	if ( schema.type === 'rich-text' ) {
+		return new Y.Text( value?.toString() ?? '' );
+	}
+
+	if ( schema.type === 'array' && schema.query && Array.isArray( value ) ) {
+		const query = schema.query;
+		const yArray = new Y.Array< Y.Map< unknown > >();
+
+		yArray.insert(
+			0,
+			value.map( ( item ) => createYMapFromQuery( query, item ) )
+		);
+
+		return yArray;
+	}
 
-	if ( isRichText ) {
-		return new Y.Text( attributeValue?.toString() ?? '' );
+	if ( schema.type === 'object' && schema.query && isRecord( value ) ) {
+		return createYMapFromQuery( schema.query, value );
 	}
 
-	return attributeValue;
+	return value;
+}
+
+/**
+ * Type guard that narrows `unknown` to `Record< string, unknown >`.
+ *
+ * @param value Value to check.
+ * @return True if `value` is a non-null, non-array object.
+ */
+function isRecord( value: unknown ): value is Record< string, unknown > {
+	return !! value && typeof value === 'object' && ! Array.isArray( value );
+}
+
+/**
+ * Create a Y.Map from a plain object, using a query schema to decide which
+ * properties should become nested Y.js types (Y.Text, Y.Array, Y.Map).
+ *
+ * @param query The query schema defining the properties.
+ * @param obj   The plain object to convert.
+ * @return A Y.Map with typed values.
+ */
+function createYMapFromQuery(
+	query: Record< string, BlockAttributeSchema >,
+	obj: unknown
+): Y.Map< unknown > {
+	if ( ! isRecord( obj ) ) {
+		return new Y.Map();
+	}
+
+	const entries: [ string, unknown ][] = Object.entries( obj ).map(
+		( [ key, val ] ): [ string, unknown ] => {
+			const subSchema = query[ key ];
+			return [ key, createYValueFromSchema( subSchema, val ) ];
+		}
+	);
+
+	return new Y.Map( entries );
 }
 
 function createNewYBlock( block: Block ): YBlock {
@@ -327,8 +483,16 @@ export function mergeCrdtBlocks(
 								currentAttribute
 							);
 
+							// Y types (Y.Text, Y.Array, Y.Map) cannot be
+							// compared with fastDeepEqual against plain values.
+							// Delegate to mergeYValue which handles no-op
+							// detection at the edges.
+							const isYType =
+								currentAttribute instanceof Y.AbstractType;
+
 							const isAttributeChanged =
 								! isExpectedType ||
+								isYType ||
 								! fastDeepEqual(
 									currentAttribute,
 									attributeValue
@@ -418,11 +582,151 @@ export function mergeCrdtBlocks(
 }
 
 /**
- * Update a single attribute on a Yjs block attributes map (currentAttributes).
+ * Merge an incoming plain array into an existing Y.Array in-place.
+ *
+ * When the array length is unchanged (stable structure), each element is
+ * merged individually via `mergeYMapValues`, preserving concurrent edits to
+ * different elements. When the length changes (structural edit such as row
+ * insertion/deletion), the Y.Array is rebuilt from scratch.
+ *
+ * @param yArray         The existing Y.Array to update.
+ * @param newValue       The new plain array to merge into the Y.Array.
+ * @param schema         The attribute schema (must have `query`).
+ * @param cursorPosition The local cursor position for rich-text delta merges.
+ */
+function mergeYArray(
+	yArray: Y.Array< unknown >,
+	newValue: unknown[],
+	schema: BlockAttributeSchema,
+	cursorPosition: number | null
+): void {
+	if ( ! schema.query ) {
+		return;
+	}
+
+	const query = schema.query;
+
+	if ( yArray.length === newValue.length ) {
+		// Same length: update each element in-place.
+		for ( let i = 0; i < newValue.length; i++ ) {
+			const currentElement = yArray.get( i );
+			const newElement = newValue[ i ];
+
+			if ( currentElement instanceof Y.Map && isRecord( newElement ) ) {
+				mergeYMapValues(
+					currentElement,
+					newElement,
+					query,
+					cursorPosition
+				);
+			} else {
+				// Element is the wrong type (e.g. partial migration) or the
+				// incoming value is not an object. Rebuild the entire array.
+				yArray.delete( 0, yArray.length );
+				yArray.insert(
+					0,
+					newValue.map( ( item ) =>
+						createYMapFromQuery( query, item )
+					)
+				);
+				return;
+			}
+		}
+	} else {
+		// Structure changed: rebuild the Y.Array.
+		yArray.delete( 0, yArray.length );
+		yArray.insert(
+			0,
+			newValue.map( ( item ) => createYMapFromQuery( query, item ) )
+		);
+	}
+}
+
+/**
+ * Merge a single value into a Y.Map entry, using the attribute schema to
+ * decide how to merge.
+ *
+ * If the current value is already a matching Y.js type (Y.Text, Y.Array,
+ * Y.Map), the update is merged in-place so concurrent edits are preserved.
+ * Otherwise the value is replaced wholesale.
+ *
+ * @param schema         The attribute type definition for this value.
+ * @param newVal         The new value to merge into the Y.Map entry.
+ * @param yMap           The Y.Map that owns this entry.
+ * @param key            The key of this entry in the Y.Map.
+ * @param cursorPosition The local cursor position for rich-text delta merges.
+ */
+function mergeYValue(
+	schema: BlockAttributeSchema | undefined,
+	newVal: unknown,
+	yMap: Y.Map< unknown >,
+	key: string,
+	cursorPosition: number | null
+): void {
+	const currentVal = yMap.get( key );
+	if (
+		schema?.type === 'rich-text' &&
+		typeof newVal === 'string' &&
+		currentVal instanceof Y.Text
+	) {
+		mergeRichTextUpdate( currentVal, newVal, cursorPosition );
+	} else if (
+		schema?.type === 'array' &&
+		schema.query &&
+		Array.isArray( newVal ) &&
+		currentVal instanceof Y.Array
+	) {
+		mergeYArray( currentVal, newVal, schema, cursorPosition );
+	} else if (
+		schema?.type === 'object' &&
+		schema.query &&
+		isRecord( newVal ) &&
+		currentVal instanceof Y.Map
+	) {
+		mergeYMapValues( currentVal, newVal, schema.query, cursorPosition );
+	} else {
+		const newYValue = createYValueFromSchema( schema, newVal );
+
+		// If createYValueFromSchema wrapped the value into a Y type, the
+		// current value is the wrong type and needs upgrading. Otherwise,
+		// only replace if the raw value actually changed.
+		if ( newYValue !== newVal || ! fastDeepEqual( currentVal, newVal ) ) {
+			yMap.set( key, newYValue );
+		}
+	}
+}
+
+/**
+ * Merge an incoming plain object into an existing Y.Map in-place, using
+ * the query schema to decide how each property should be merged.
  *
- * For rich-text attributes that already exist as Y.Text instances, the update
- * is applied as a delta merge so that concurrent edits are preserved. All
- * other attributes are replaced wholesale via `createNewYAttributeValue`.
+ * Properties present in the Y.Map but absent from `newObj` are deleted.
+ *
+ * @param yMap           The existing Y.Map to update.
+ * @param newObj         The new plain object to merge into the Y.Map.
+ * @param query          The query schema defining property types.
+ * @param cursorPosition The local cursor position for rich-text delta merges.
+ */
+function mergeYMapValues(
+	yMap: Y.Map< unknown >,
+	newObj: Record< string, unknown >,
+	query: Record< string, BlockAttributeSchema >,
+	cursorPosition: number | null
+): void {
+	for ( const [ key, newVal ] of Object.entries( newObj ) ) {
+		mergeYValue( query[ key ], newVal, yMap, key, cursorPosition );
+	}
+
+	// Delete properties absent from the incoming object.
+	for ( const key of yMap.keys() ) {
+		if ( ! Object.hasOwn( newObj, key ) ) {
+			yMap.delete( key );
+		}
+	}
+}
+
+/**
+ * Update a single attribute on a Yjs block attributes map (currentAttributes).
  *
  * @param blockName         The block type name, e.g. 'core/paragraph'.
  * @param attributeName     The name of the attribute to update, e.g. 'content'.
@@ -437,28 +741,22 @@ function updateYBlockAttribute(
 	currentAttributes: YBlockAttributes,
 	cursorPosition: number | null
 ): void {
-	const isRichText = isRichTextAttribute( blockName, attributeName );
-	const currentAttribute = currentAttributes.get( attributeName );
+	const schema = getBlockAttributeSchema( blockName, attributeName );
 
-	if (
-		isRichText &&
-		'string' === typeof attributeValue &&
-		currentAttributes.has( attributeName ) &&
-		currentAttribute instanceof Y.Text
-	) {
-		// Rich text values are stored as persistent Y.Text instances.
-		// Update the value with a delta in place.
-		mergeRichTextUpdate( currentAttribute, attributeValue, cursorPosition );
-	} else {
-		currentAttributes.set(
-			attributeName,
-			createNewYAttributeValue( blockName, attributeName, attributeValue )
-		);
-	}
+	mergeYValue(
+		schema,
+		attributeValue,
+		currentAttributes,
+		attributeName,
+		cursorPosition
+	);
 }
 
 // Cached block attribute types, populated once from getBlockTypes().
-let cachedBlockAttributeTypes: Map< string, Map< string, BlockAttributeType > >;
+let cachedBlockAttributeSchemas: Map<
+	string,
+	Map< string, BlockAttributeSchema >
+>;
 
 /**
  * Get the attribute type definition for a block attribute.
@@ -467,22 +765,22 @@ let cachedBlockAttributeTypes: Map< string, Map< string, BlockAttributeType > >;
  * @param attributeName The name of the attribute, e.g. 'content'.
  * @return The type definition of the attribute.
  */
-function getBlockAttributeType(
+function getBlockAttributeSchema(
 	blockName: string,
 	attributeName: string
-): BlockAttributeType | undefined {
-	if ( ! cachedBlockAttributeTypes ) {
+): BlockAttributeSchema | undefined {
+	if ( ! cachedBlockAttributeSchemas ) {
 		// Parse the attributes for all blocks once.
-		cachedBlockAttributeTypes = new Map();
+		cachedBlockAttributeSchemas = new Map();
 
 		for ( const blockType of getBlockTypes() as BlockType[] ) {
-			cachedBlockAttributeTypes.set(
+			cachedBlockAttributeSchemas.set(
 				blockType.name,
-				new Map< string, BlockAttributeType >(
+				new Map< string, BlockAttributeSchema >(
 					Object.entries( blockType.attributes ?? {} ).map(
 						( [ name, definition ] ) => {
-							const { role, type } = definition;
-							return [ name, { role, type } ];
+							const { role, type, query } = definition;
+							return [ name, { role, type, query } ];
 						}
 					)
 				)
@@ -490,7 +788,7 @@ function getBlockAttributeType(
 		}
 	}
 
-	return cachedBlockAttributeTypes.get( blockName )?.get( attributeName );
+	return cachedBlockAttributeSchemas.get( blockName )?.get( attributeName );
 }
 
 /**
@@ -506,20 +804,24 @@ function isExpectedAttributeType(
 	attributeName: string,
 	attributeValue: unknown
 ): boolean {
-	const expectedAttributeType = getBlockAttributeType(
-		blockName,
-		attributeName
-	)?.type;
+	const schema = getBlockAttributeSchema( blockName, attributeName );
 
-	if ( expectedAttributeType === 'rich-text' ) {
+	if ( schema?.type === 'rich-text' ) {
 		return attributeValue instanceof Y.Text;
 	}
 
-	if ( expectedAttributeType === 'string' ) {
+	if ( schema?.type === 'string' ) {
 		return typeof attributeValue === 'string';
 	}
 
-	// No other types comparisons use special logic.
+	if ( schema?.type === 'array' && schema.query ) {
+		return attributeValue instanceof Y.Array;
+	}
+
+	if ( schema?.type === 'object' && schema.query ) {
+		return attributeValue instanceof Y.Map;
+	}
+
 	return true;
 }
 
@@ -532,22 +834,8 @@ function isExpectedAttributeType(
  * @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.
- *
- * @param blockName     The name of the block, e.g. 'core/paragraph'.
- * @param attributeName The name of the attribute to check, e.g. 'content'.
- * @return True if the attribute is rich-text typed, false otherwise.
- */
-function isRichTextAttribute(
-	blockName: string,
-	attributeName: string
-): boolean {
 	return (
-		'rich-text' === getBlockAttributeType( blockName, attributeName )?.type
+		'local' === getBlockAttributeSchema( blockName, attributeName )?.role
 	);
 }
 

package/src/utils/crdt-text.ts

@@ -0,0 +1,43 @@
+/**
+ * WordPress dependencies
+ */
+import { RichTextData } from '@wordpress/rich-text';
+
+const RICH_TEXT_CACHE_MAX_SIZE = 500;
+
+/**
+ * Returns a function that converts HTML strings to RichTextData instances,
+ * using a FIFO cache bounded by `maxSize` to avoid re-parsing identical
+ * strings. Repeated calls with the same string return the cached instance
+ * without re-running the HTML parser and DOM traversal.
+ *
+ * @param maxSize Maximum number of entries to hold in the cache.
+ * @return A cached version of RichTextData.fromHTMLString.
+ */
+export function createRichTextDataCache(
+	maxSize: number
+): ( value: string ) => RichTextData {
+	const cache = new Map< string, RichTextData >();
+
+	return function ( value: string ): RichTextData {
+		const cached = cache.get( value );
+
+		if ( cached ) {
+			return cached;
+		}
+
+		const result = RichTextData.fromHTMLString( value );
+
+		if ( cache.size >= maxSize ) {
+			// Evict the oldest entry (Map preserves insertion order).
+			cache.delete( cache.keys().next().value! );
+		}
+
+		cache.set( value, result );
+		return result;
+	};
+}
+
+export const getCachedRichTextData = createRichTextDataCache(
+	RICH_TEXT_CACHE_MAX_SIZE
+);

package/src/utils/crdt.ts

@@ -11,6 +11,8 @@ import { __unstableSerializeAndClean } from '@wordpress/blocks';
 import {
 	type CRDTDoc,
 	type ObjectData,
+	type ObjectID,
+	type ObjectType,
 	type SyncConfig,
 	Y,
 } from '@wordpress/sync';
@@ -20,6 +22,7 @@ import {
  */
 import { BaseAwareness } from '../awareness/base-awareness';
 import {
+	deserializeBlockAttributes,
 	mergeCrdtBlocks,
 	mergeRichTextUpdate,
 	type Block,
@@ -382,6 +385,15 @@ export function getPostChangesFromCRDTDoc(
 		} )
 	);
 
+	// Blocks extracted from the CRDT document have rich-text attributes as
+	// plain strings (from Y.Text.toJSON()). Convert them back to RichTextData
+	// so block edit components receive the same types as locally-created blocks.
+	if ( changes.blocks ) {
+		changes.blocks = deserializeBlockAttributes(
+			changes.blocks as Block[]
+		);
+	}
+
 	// Meta changes must be merged with the edited record since not all meta
 	// properties are synced.
 	if ( 'object' === typeof changes.meta ) {
@@ -418,6 +430,19 @@ export const defaultSyncConfig: SyncConfig = {
 	getChangesFromCRDTDoc: defaultGetChangesFromCRDTDoc,
 };
 
+/**
+ * This default collection sync config can be used to sync entity collections
+ * (e.g., block comments) where we are not interested in merging changes at the
+ * individual record level, but instead want to replace the entire collection
+ * when changes are detected.
+ */
+export const defaultCollectionSyncConfig: SyncConfig = {
+	applyChangesToCRDTDoc: () => {},
+	getChangesFromCRDTDoc: () => ( {} ),
+	shouldSync: ( _: ObjectType, objectId: ObjectID | null ) =>
+		null === objectId,
+};
+
 /**
  * Extract the raw string value from a property that may be a string or an object
  * with a `raw` property (`RenderedText`).

package/src/utils/index.js

@@ -5,7 +5,6 @@ export { default as forwardResolver } from './forward-resolver';
 export { default as onSubKey } from './on-sub-key';
 export { default as replaceAction } from './replace-action';
 export { default as withWeakMapCache } from './with-weak-map-cache';
-export { default as isRawAttribute } from './is-raw-attribute';
 export { default as setNestedValue } from './set-nested-value';
 export { default as getNestedValue } from './get-nested-value';
 export { default as isNumericID } from './is-numeric-id';