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

package/src/private-apis.js

@@ -6,7 +6,9 @@ import { RECEIVE_INTERMEDIATE_RESULTS } from './utils';
 import {
 	useActiveCollaborators,
 	useResolvedSelection,
-	useLastPostSave,
+	useOnCollaboratorJoin,
+	useOnCollaboratorLeave,
+	useOnPostSave,
 } from './hooks/use-post-editor-awareness-state';
 import { lock } from './lock-unlock';
 import { retrySyncConnection } from './sync';
@@ -18,5 +20,7 @@ lock( privateApis, {
 	retrySyncConnection,
 	useActiveCollaborators,
 	useResolvedSelection,
-	useLastPostSave,
+	useOnCollaboratorJoin,
+	useOnCollaboratorLeave,
+	useOnPostSave,
 } );

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

@@ -15,6 +15,8 @@ import { withWeakMapCache, getNormalizedCommaSeparable } from '../utils';
  *
  * @property {number}      page      The query page (1-based index, default 1).
  * @property {number}      perPage   Items per page for query (default 10).
+ * @property {number}      offset    Absolute item offset (default undefined).
+ *                                   When present, also encoded into stableKey.
  * @property {string}      stableKey An encoded stable string of all non-
  *                                   pagination, non-fields query parameters.
  * @property {?(string[])} fields    Target subset of fields to derive from
@@ -41,6 +43,7 @@ export function getQueryParts( query ) {
 		stableKey: '',
 		page: 1,
 		perPage: 10,
+		offset: undefined,
 		fields: null,
 		include: null,
 		context: 'default',
@@ -67,6 +70,16 @@ export function getQueryParts( query ) {
 				break;
 
 			default:
+				// Extract offset for use in pagination calculations while
+				// still including it in the stableKey (different offsets
+				// produce different result sets).
+				if ( key === 'offset' ) {
+					const numericOffset = Number( value );
+					if ( Number.isFinite( numericOffset ) ) {
+						parts.offset = numericOffset;
+					}
+				}
+
 				// While in theory, we could exclude "_fields" from the stableKey
 				// because two request with different fields have the same results
 				// We're not able to ensure that because the server can decide to omit

package/src/queried-data/selectors.js

@@ -32,14 +32,17 @@ const queriedItemsCacheByState = new WeakMap();
  * @return {?Array} Query items.
  */
 function getQueriedItemsUncached( state, query ) {
-	const { stableKey, page, perPage, include, fields, context } =
-		getQueryParts( query );
-	let itemIds;
-
-	if ( state.queries?.[ context ]?.[ stableKey ] ) {
-		itemIds = state.queries[ context ][ stableKey ].itemIds;
-	}
-
+	const {
+		stableKey,
+		page,
+		perPage,
+		offset: queryOffset,
+		include,
+		fields,
+		context,
+	} = getQueryParts( query );
+
+	const itemIds = state.queries?.[ context ]?.[ stableKey ]?.itemIds;
 	if ( ! itemIds ) {
 		return null;
 	}
@@ -50,6 +53,28 @@ function getQueriedItemsUncached( state, query ) {
 			? itemIds.length
 			: Math.min( startOffset + perPage, itemIds.length );
 
+	// If the requested page range exceeds the stored itemIds, the data for
+	// this specific pagination window may not have been fetched yet. Return
+	// null unless totalItems confirms we already have all available items.
+	if ( perPage !== -1 && itemIds.length < startOffset + perPage ) {
+		const totalItems =
+			state.queries[ context ][ stableKey ].meta?.totalItems;
+		if ( Number.isFinite( totalItems ) ) {
+			// For offset-based queries, totalItems (from X-WP-Total)
+			// reflects the global count of all matching items, not the
+			// count remaining after the offset. The number of items
+			// available for this query is (totalItems - offset), so a
+			// partial last page is expected and valid.
+			const effectiveTotal =
+				queryOffset !== undefined
+					? totalItems - queryOffset
+					: totalItems;
+			if ( itemIds.length < effectiveTotal ) {
+				return null;
+			}
+		}
+	}
+
 	const items = [];
 	for ( let i = startOffset; i < endOffset; i++ ) {
 		const itemId = itemIds[ i ];

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

@@ -239,4 +239,187 @@ describe( 'getQueriedItems', () => {
 
 		expect( result ).toBe( null );
 	} );
+
+	it( 'should return null when per_page exceeds stored itemIds and more items exist', () => {
+		const state = {
+			items: {
+				default: {
+					1: { id: 1 },
+					2: { id: 2 },
+				},
+			},
+			itemIsComplete: {
+				default: { 1: true, 2: true },
+			},
+			queries: {
+				default: {
+					'': {
+						itemIds: [ 1, 2 ],
+						meta: { totalItems: 5 },
+					},
+				},
+			},
+		};
+
+		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;
 }