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

package/src/queried-data/test/get-query-parts.js

@@ -11,6 +11,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 2,
 			perPage: 2,
+			offset: undefined,
 			stableKey: '',
 			fields: null,
 			include: null,
@@ -28,6 +29,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: 'include=1',
 			fields: null,
 			include: [ 1 ],
@@ -43,6 +45,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: '%3F=%26&b=2',
 			fields: null,
 			include: null,
@@ -56,6 +59,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: 'a%5B0%5D=1&a%5B1%5D=2',
 			fields: null,
 			include: null,
@@ -71,6 +75,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: 'b=2',
 			fields: null,
 			include: null,
@@ -84,6 +89,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: -1,
+			offset: undefined,
 			stableKey: 'b=2',
 			fields: null,
 			include: null,
@@ -97,6 +103,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: '_fields=id%2Ctitle',
 			fields: [ 'id', 'title' ],
 			include: null,
@@ -109,10 +116,37 @@ describe( 'getQueryParts', () => {
 		expect( parts ).toEqual( {
 			page: 1,
 			perPage: 10,
+			offset: undefined,
 			stableKey: '',
 			include: null,
 			fields: null,
 			context: 'view',
 		} );
 	} );
+
+	it( 'extracts offset and includes it in stableKey', () => {
+		const parts = getQueryParts( {
+			per_page: 50,
+			offset: 100,
+		} );
+
+		expect( parts ).toEqual( {
+			context: 'default',
+			page: 1,
+			perPage: 50,
+			offset: 100,
+			stableKey: 'offset=100',
+			fields: null,
+			include: null,
+		} );
+	} );
+
+	it( 'ignores non-numeric offset values', () => {
+		const parts = getQueryParts( {
+			per_page: 10,
+			offset: 'abc',
+		} );
+
+		expect( parts.offset ).toBeUndefined();
+	} );
 } );

package/src/queried-data/test/selectors.js

@@ -264,4 +264,162 @@ describe( 'getQueriedItems', () => {
 		const result = getQueriedItems( state, { per_page: 3 } );
 		expect( result ).toBe( null );
 	} );
+
+	it( 'should return items for offset-based query on the last partial page', () => {
+		// Infinite scroll scenario: 103 total items, perPage=50, and the
+		// last batch starts at offset=100. The API returns 3 items (items
+		// 101-103). X-WP-Total is 103 (the global count). The selector
+		// should recognise this as a complete response since
+		// 103 - 100 = 3 expected items.
+		const state = {
+			items: {
+				default: {
+					101: { id: 101 },
+					102: { id: 102 },
+					103: { id: 103 },
+				},
+			},
+			itemIsComplete: {
+				default: { 101: true, 102: true, 103: true },
+			},
+			queries: {
+				default: {
+					'offset=100': {
+						itemIds: [ 101, 102, 103 ],
+						meta: { totalItems: 103 },
+					},
+				},
+			},
+		};
+
+		const result = getQueriedItems( state, {
+			per_page: 50,
+			offset: 100,
+		} );
+		expect( result ).toEqual( [ { id: 101 }, { id: 102 }, { id: 103 } ] );
+	} );
+
+	it( 'should return null for offset-based query when items are still missing', () => {
+		// Offset=50, perPage=50, totalItems=200: the API should return
+		// 50 items for this batch but only 2 are stored so far.
+		const state = {
+			items: {
+				default: {
+					51: { id: 51 },
+					52: { id: 52 },
+				},
+			},
+			itemIsComplete: {
+				default: { 51: true, 52: true },
+			},
+			queries: {
+				default: {
+					'offset=50': {
+						itemIds: [ 51, 52 ],
+						meta: { totalItems: 200 },
+					},
+				},
+			},
+		};
+
+		const result = getQueriedItems( state, {
+			per_page: 50,
+			offset: 50,
+		} );
+		expect( result ).toBe( null );
+	} );
+
+	it( 'should return null for offset query when items are still missing', () => {
+		// Query Block scenario: offset=3 with per_page=10. The effective
+		// total is totalItems - offset = 47. Only 5 items are stored, so
+		// the data is still incomplete.
+		const state = {
+			items: {
+				default: {
+					4: { id: 4 },
+					5: { id: 5 },
+					6: { id: 6 },
+					7: { id: 7 },
+					8: { id: 8 },
+				},
+			},
+			itemIsComplete: {
+				default: { 4: true, 5: true, 6: true, 7: true, 8: true },
+			},
+			queries: {
+				default: {
+					'offset=3': {
+						itemIds: [ 4, 5, 6, 7, 8 ],
+						meta: { totalItems: 50 },
+					},
+				},
+			},
+		};
+
+		const result = getQueriedItems( state, {
+			per_page: 10,
+			offset: 3,
+		} );
+		expect( result ).toBe( null );
+	} );
+
+	it( 'should treat offset=0 the same as no offset', () => {
+		// The Query Block defaults to offset=0. Since
+		// effectiveTotal = totalItems - 0 = totalItems, this should
+		// behave identically to a query without offset.
+		const state = {
+			items: {
+				default: {
+					1: { id: 1 },
+					2: { id: 2 },
+				},
+			},
+			itemIsComplete: {
+				default: { 1: true, 2: true },
+			},
+			queries: {
+				default: {
+					'offset=0': {
+						itemIds: [ 1, 2 ],
+						meta: { totalItems: 5 },
+					},
+				},
+			},
+		};
+
+		// 2 items stored, but 5 total exist — should return null.
+		const result = getQueriedItems( state, {
+			per_page: 3,
+			offset: 0,
+		} );
+		expect( result ).toBe( null );
+	} );
+
+	it( 'should return empty array when offset equals totalItems', () => {
+		// Edge case: offset lands exactly at the end (e.g. 84 items,
+		// per_page=7, offset=84). The API returns 0 items and that is
+		// a complete response — effectiveTotal is 0.
+		const state = {
+			items: {
+				default: {},
+			},
+			itemIsComplete: {
+				default: {},
+			},
+			queries: {
+				default: {
+					'offset=84': {
+						itemIds: [],
+						meta: { totalItems: 84 },
+					},
+				},
+			},
+		};
+
+		const result = getQueriedItems( state, {
+			per_page: 7,
+			offset: 84,
+		} );
+		expect( result ).toEqual( [] );
+	} );
 } );

package/src/reducer.js

@@ -16,6 +16,7 @@ import { createUndoManager } from '@wordpress/undo-manager';
 import { ifMatchingAction, replaceAction } from './utils';
 import { reducer as queriedDataReducer } from './queried-data';
 import { rootEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
+import { ConnectionErrorCode } from './sync';
 
 /** @typedef {import('./types').AnyFunction} AnyFunction */
 
@@ -706,6 +707,16 @@ export function collaborationSupported( state = true, action ) {
 	switch ( action.type ) {
 		case 'SET_COLLABORATION_SUPPORTED':
 			return action.supported;
+
+		case 'SET_SYNC_CONNECTION_STATUS':
+			if (
+				ConnectionErrorCode.DOCUMENT_SIZE_LIMIT_EXCEEDED ===
+				action.status?.error?.code
+			) {
+				return false;
+			}
+
+			return state;
 	}
 	return state;
 }

package/src/sync.ts

@@ -12,6 +12,7 @@ import {
 import { unlock } from './lock-unlock';
 
 const {
+	ConnectionErrorCode,
 	createSyncManager,
 	Delta,
 	CRDT_DOC_META_PERSISTENCE_KEY,
@@ -22,6 +23,7 @@ const {
 } = unlock( syncPrivateApis );
 
 export {
+	ConnectionErrorCode,
 	Delta,
 	CRDT_DOC_META_PERSISTENCE_KEY,
 	CRDT_RECORD_MAP_KEY,

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

@@ -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,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 {