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

package/src/test/entities.js

@@ -8,6 +8,10 @@ jest.mock( '../sync', () => ( {
 	...jest.requireActual( '../sync' ),
 	getSyncManager: jest.fn(),
 } ) );
+jest.mock( '../utils/crdt', () => ( {
+	...jest.requireActual( '../utils/crdt' ),
+	applyPostChangesToCRDTDoc: jest.fn(),
+} ) );
 
 /**
  * Internal dependencies
@@ -19,7 +23,10 @@ import {
 	additionalEntityConfigLoaders,
 } from '../entities';
 import { getSyncManager } from '../sync';
-import { POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE } from '../utils/crdt';
+import {
+	applyPostChangesToCRDTDoc,
+	POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE,
+} from '../utils/crdt';
 
 describe( 'getMethodName', () => {
 	it( 'should return the right method name for an entity with the root kind', () => {
@@ -127,6 +134,183 @@ describe( 'prePersistPostType', () => {
 	} );
 } );
 
+describe( 'loadPostTypeEntities', () => {
+	let originalCollaborationEnabled;
+
+	beforeEach( () => {
+		apiFetch.mockReset();
+		applyPostChangesToCRDTDoc.mockReset();
+		originalCollaborationEnabled = window._wpCollaborationEnabled;
+	} );
+
+	afterEach( () => {
+		window._wpCollaborationEnabled = originalCollaborationEnabled;
+	} );
+
+	it( 'should include custom taxonomy rest_bases in synced properties when collaboration is enabled', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			book: {
+				name: 'Books',
+				rest_base: 'books',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'genre', 'audience' ],
+			},
+		};
+		const mockTaxonomies = {
+			genre: {
+				name: 'Genres',
+				rest_base: 'genres',
+				rest_namespace: 'wp/v2',
+			},
+			audience: {
+				name: 'Audiences',
+				rest_base: 'audiences',
+				rest_namespace: 'wp/v2',
+			},
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( mockTaxonomies );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const bookEntity = entities.find( ( e ) => e.name === 'book' );
+
+		bookEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		expect( applyPostChangesToCRDTDoc ).toHaveBeenCalledWith(
+			{},
+			{},
+			expect.any( Set )
+		);
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).toContain( 'genres' );
+		expect( syncedProperties ).toContain( 'audiences' );
+	} );
+
+	it( 'should not fetch taxonomies when collaboration is disabled', async () => {
+		window._wpCollaborationEnabled = false;
+
+		const mockPostTypes = {
+			post: {
+				name: 'Posts',
+				rest_base: 'posts',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'category', 'post_tag' ],
+			},
+		};
+
+		apiFetch.mockResolvedValueOnce( mockPostTypes );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const postEntity = entities.find( ( e ) => e.name === 'post' );
+
+		postEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		// Only one apiFetch call (post types), no taxonomy fetch.
+		expect( apiFetch ).toHaveBeenCalledTimes( 1 );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).not.toContain( 'categories' );
+		expect( syncedProperties ).not.toContain( 'tags' );
+	} );
+
+	it( 'should skip taxonomy rest_base when taxonomy is not found in fetched taxonomies', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			book: {
+				name: 'Books',
+				rest_base: 'books',
+				rest_namespace: 'wp/v2',
+				taxonomies: [ 'genre', 'missing_taxonomy' ],
+			},
+		};
+		const mockTaxonomies = {
+			genre: {
+				name: 'Genres',
+				rest_base: 'genres',
+				rest_namespace: 'wp/v2',
+			},
+			// 'missing_taxonomy' is intentionally absent.
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( mockTaxonomies );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const bookEntity = entities.find( ( e ) => e.name === 'book' );
+
+		bookEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		expect( syncedProperties ).toContain( 'genres' );
+		// missing_taxonomy has no rest_base entry, so nothing should be added for it.
+		expect( syncedProperties.size ).toBe( 16 ); // 15 base + 1 taxonomy (genres)
+	} );
+
+	it( 'should include base synced properties regardless of taxonomies', async () => {
+		window._wpCollaborationEnabled = true;
+
+		const mockPostTypes = {
+			page: {
+				name: 'Pages',
+				rest_base: 'pages',
+				rest_namespace: 'wp/v2',
+				taxonomies: [],
+			},
+		};
+
+		apiFetch
+			.mockResolvedValueOnce( mockPostTypes )
+			.mockResolvedValueOnce( {} );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const pageEntity = entities.find( ( e ) => e.name === 'page' );
+
+		pageEntity.syncConfig.applyChangesToCRDTDoc( {}, {} );
+
+		const syncedProperties = applyPostChangesToCRDTDoc.mock.calls[ 0 ][ 2 ];
+		const expectedBase = [
+			'author',
+			'blocks',
+			'content',
+			'comment_status',
+			'date',
+			'excerpt',
+			'featured_media',
+			'format',
+			'meta',
+			'ping_status',
+			'slug',
+			'status',
+			'sticky',
+			'template',
+			'title',
+		];
+		for ( const prop of expectedBase ) {
+			expect( syncedProperties ).toContain( prop );
+		}
+		expect( syncedProperties.size ).toBe( 15 );
+	} );
+} );
+
 describe( 'loadTaxonomyEntities', () => {
 	beforeEach( () => {
 		apiFetch.mockReset();

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;
 }
@@ -127,6 +133,6 @@ export type SelectionState =
 	| SelectionWholeBlock;
 
 export interface ResolvedSelection {
-	textIndex: number | null;
+	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

@@ -16,6 +16,7 @@ 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 {
@@ -25,6 +26,7 @@ interface BlockAttributes {
 interface BlockAttributeType {
 	role?: string;
 	type?: string;
+	query?: Record< string, BlockAttributeType >;
 }
 
 interface BlockType {
@@ -62,6 +64,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 +106,7 @@ function makeBlockAttributesSerializable(
 			continue;
 		}
 
-		if ( value instanceof RichTextData ) {
-			newAttributes[ key ] = value.valueOf();
-		}
+		newAttributes[ key ] = serializeAttributeValue( value );
 	}
 	return newAttributes;
 }
@@ -93,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: BlockAttributeType | 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 = getBlockAttributeType( name, key );
+
+			if ( schema ) {
+				newAttributes[ key ] = deserializeAttributeValue(
+					schema,
+					value
+				);
+			}
+		}
+
+		return {
+			...rest,
+			name,
+			attributes: newAttributes,
+			innerBlocks: deserializeBlockAttributes( innerBlocks ?? [] ),
+		};
+	} );
+}
+
 /**
  * @param {any}   gblock
  * @param {Y.Map} yblock
@@ -452,8 +562,8 @@ function getBlockAttributeType(
 				new Map< string, BlockAttributeType >(
 					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 } ];
 						}
 					)
 				)

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-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-user-selections.ts

@@ -12,18 +12,18 @@ 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 type { SelectionDirection } from '../types';
-import {
-	type AbsoluteBlockIndexPath,
-	type WPBlockSelection,
-	type SelectionState,
-	type SelectionNone,
-	type SelectionCursor,
-	type SelectionInOneBlock,
-	type SelectionInMultipleBlocks,
-	type SelectionWholeBlock,
-	type CursorPosition,
+import { getRootMap, richTextOffsetToHtmlIndex } from './crdt-utils';
+import type {
+	AbsoluteBlockIndexPath,
+	WPBlockSelection,
+	SelectionState,
+	SelectionNone,
+	SelectionCursor,
+	SelectionInOneBlock,
+	SelectionInMultipleBlocks,
+	SelectionWholeBlock,
+	SelectionDirection,
+	CursorPosition,
 } from '../types';
 
 /**
@@ -178,7 +178,7 @@ function getCursorPosition(
 
 	const relativePosition = Y.createRelativePositionFromTypeIndex(
 		currentYText,
-		selection.offset
+		richTextOffsetToHtmlIndex( currentYText.toString(), selection.offset )
 	);
 
 	return {

package/src/utils/crdt-utils.ts

@@ -2,6 +2,7 @@
  * WordPress dependencies
  */
 import { Y } from '@wordpress/sync';
+import { create, insert, toHTMLString } from '@wordpress/rich-text';
 
 /**
  * Internal dependencies
@@ -104,6 +105,104 @@ export function findBlockByClientIdInDoc(
 	return findBlockByClientIdInBlocks( blockId, blocks );
 }
 
+// Marker for insertion.
+const MARKER_START = 0xe000;
+
+/**
+ * Pick a marker character that does not appear in `text`. Returns the marker
+ * or `null` if all candidates are present (extremely unlikely in practice).
+ *
+ * @param text The string to check for existing marker characters.
+ */
+function pickMarker( text: string ): string | null {
+	const tryCount = 0x10;
+
+	// Scan the unicode private use area for the first code point not present
+	// in the text.
+	for ( let code = MARKER_START; code < MARKER_START + tryCount; code++ ) {
+		const candidate = String.fromCharCode( code );
+
+		if ( ! text.includes( candidate ) ) {
+			return candidate;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Convert an HTML character index (counting tag characters) to a rich-text
+ * offset (counting only text characters). Used on read paths where Y.Text
+ * resolves to an HTML index but the block editor expects a text offset.
+ *
+ * @param html      The full HTML string from Y.Text.
+ * @param htmlIndex The HTML character index.
+ * @return The corresponding rich-text offset.
+ */
+export function htmlIndexToRichTextOffset(
+	html: string,
+	htmlIndex: number
+): number {
+	if ( ! html.includes( '<' ) && ! html.includes( '&' ) ) {
+		return htmlIndex;
+	}
+
+	const marker = pickMarker( html );
+	if ( ! marker ) {
+		return htmlIndex;
+	}
+
+	// Insert marker and let create() do the parsing.
+	const withMarker =
+		html.slice( 0, htmlIndex ) + marker + html.slice( htmlIndex );
+	const value = create( { html: withMarker } );
+	const markerPos = value.text.indexOf( marker );
+
+	return markerPos === -1 ? htmlIndex : markerPos;
+}
+
+/**
+ * Convert a rich-text offset (counting only text characters) to an HTML
+ * character index (counting tag characters). Used on write paths where the
+ * block editor provides a text offset but Y.Text expects an HTML index.
+ *
+ * @param html           The full HTML string from Y.Text.
+ * @param richTextOffset The rich-text text offset.
+ * @return The corresponding HTML character index.
+ */
+export function richTextOffsetToHtmlIndex(
+	html: string,
+	richTextOffset: number
+): number {
+	if ( ! html.includes( '<' ) && ! html.includes( '&' ) ) {
+		return richTextOffset;
+	}
+
+	const marker = pickMarker( html );
+	if ( ! marker ) {
+		return richTextOffset;
+	}
+
+	const value = create( { html } );
+	const markerValue = create( { text: marker } );
+	// The marker must inherit the formatting at the insertion point so that
+	// toHTMLString does not split surrounding tags (e.g. <strong>) around it.
+	if ( value.formats[ richTextOffset ] ) {
+		markerValue.formats[ 0 ] = value.formats[ richTextOffset ];
+	}
+
+	const withMarker = insert(
+		value,
+		markerValue,
+		richTextOffset,
+		richTextOffset
+	);
+
+	const htmlWithMarker = toHTMLString( { value: withMarker } );
+	const markerIndex = htmlWithMarker.indexOf( marker );
+	return markerIndex === -1 ? richTextOffset : markerIndex;
+}
+
 function findBlockByClientIdInBlocks(
 	blockId: string,
 	blocks: YBlocks