@wordpress/core-data 6.22.0 → 6.24.0

package/src/entity-types/global-styles-revision.ts

@@ -0,0 +1,47 @@
+/**
+ * Internal dependencies
+ */
+import type { Context, ContextualField, OmitNevers } from './helpers';
+
+import type { BaseEntityRecords as _BaseEntityRecords } from './base-entity-records';
+
+declare module './base-entity-records' {
+	export namespace BaseEntityRecords {
+		export interface GlobalStylesRevision< C extends Context > {
+			/**
+			 * The ID for the author of the global styles revision.
+			 */
+			author: number;
+			/**
+			 * The date the post global styles revision published, in the site's timezone.
+			 */
+			date: string | null;
+			/**
+			 * The date the global styles revision was published, as GMT.
+			 */
+			date_gmt: ContextualField< string | null, 'view' | 'edit', C >;
+			/**
+			 * Unique identifier for the revision.
+			 */
+			id: number;
+			/**
+			 * The date the global styles revision was last modified, in the site's timezone.
+			 */
+			modified: ContextualField< string, 'view' | 'edit', C >;
+			/**
+			 * The date the global styles revision was last modified, as GMT.
+			 */
+			modified_gmt: ContextualField< string, 'view' | 'edit', C >;
+			/**
+			 * Identifier for the parent of the revision.
+			 */
+			parent: number;
+			styles: Record< string, Object >;
+			settings: Record< string, Object >;
+		}
+	}
+}
+
+export type GlobalStylesRevision< C extends Context = 'view' > = OmitNevers<
+	_BaseEntityRecords.GlobalStylesRevision< C >
+>;

package/src/entity-types/index.ts

@@ -4,12 +4,14 @@
 import type { Context, Updatable } from './helpers';
 import type { Attachment } from './attachment';
 import type { Comment } from './comment';
+import type { GlobalStylesRevision } from './global-styles-revision';
 import type { MenuLocation } from './menu-location';
 import type { NavMenu } from './nav-menu';
 import type { NavMenuItem } from './nav-menu-item';
 import type { Page } from './page';
 import type { Plugin } from './plugin';
 import type { Post } from './post';
+import type { PostRevision } from './post-revision';
 import type { Settings } from './settings';
 import type { Sidebar } from './sidebar';
 import type { Taxonomy } from './taxonomy';
@@ -27,12 +29,14 @@ export type {
 	Attachment,
 	Comment,
 	Context,
+	GlobalStylesRevision,
 	MenuLocation,
 	NavMenu,
 	NavMenuItem,
 	Page,
 	Plugin,
 	Post,
+	PostRevision,
 	Settings,
 	Sidebar,
 	Taxonomy,
@@ -82,12 +86,14 @@ export interface PerPackageEntityRecords< C extends Context > {
 	core:
 		| Attachment< C >
 		| Comment< C >
+		| GlobalStylesRevision< C >
 		| MenuLocation< C >
 		| NavMenu< C >
 		| NavMenuItem< C >
 		| Page< C >
 		| Plugin< C >
 		| Post< C >
+		| PostRevision< C >
 		| Settings< C >
 		| Sidebar< C >
 		| Taxonomy< C >

package/src/entity-types/post-revision.ts

@@ -0,0 +1,93 @@
+/**
+ * Internal dependencies
+ */
+import type {
+	Context,
+	ContextualField,
+	RenderedText,
+	OmitNevers,
+} from './helpers';
+
+import type { BaseEntityRecords as _BaseEntityRecords } from './base-entity-records';
+
+declare module './base-entity-records' {
+	export namespace BaseEntityRecords {
+		export interface PostRevision< C extends Context > {
+			/**
+			 * The ID for the author of the post revision.
+			 */
+			author: number;
+			/**
+			 * The content for the post.
+			 */
+			content: ContextualField<
+				RenderedText< C > & {
+					/**
+					 * Whether the content is protected with a password.
+					 */
+					is_protected: boolean;
+					/**
+					 * Version of the content block format used by the post.
+					 */
+					block_version: ContextualField< string, 'edit', C >;
+				},
+				'view' | 'edit',
+				C
+			>;
+			/**
+			 * The date the post was published, in the site's timezone.
+			 */
+			date: string | null;
+			/**
+			 * The date the post was published, as GMT.
+			 */
+			date_gmt: ContextualField< string | null, 'view' | 'edit', C >;
+			/**
+			 * The excerpt for the post revision.
+			 */
+			excerpt: RenderedText< C > & {
+				protected: boolean;
+			};
+			/**
+			 * The globally unique identifier for the post.
+			 */
+			guid: ContextualField< RenderedText< C >, 'view' | 'edit', C >;
+			/**
+			 * Unique identifier for the revision.
+			 */
+			id: number;
+			/**
+			 * Meta fields.
+			 */
+			meta: ContextualField<
+				Record< string, string >,
+				'view' | 'edit',
+				C
+			>;
+			/**
+			 * The date the post was last modified, in the site's timezone.
+			 */
+			modified: ContextualField< string, 'view' | 'edit', C >;
+			/**
+			 * The date the post revision was last modified, as GMT.
+			 */
+			modified_gmt: ContextualField< string, 'view' | 'edit', C >;
+			/**
+			 * Identifier for the parent of the revision.
+			 */
+			parent: number;
+			/**
+			 * An alphanumeric identifier for the post unique to its type.
+			 */
+			slug: string;
+			/**
+			 * The title for the post revision.
+			 */
+			title: RenderedText< C >;
+		}
+	}
+}
+
+export type PostRevision< C extends Context = 'view' > = OmitNevers<
+	_BaseEntityRecords.PostRevision< C >
+>;

package/src/hooks/test/use-entity-record.js

@@ -23,6 +23,7 @@ describe( 'useEntityRecord', () => {
 	beforeEach( () => {
 		registry = createRegistry();
 		registry.register( coreDataStore );
+		triggerFetch.mockReset();
 	} );
 
 	const TEST_RECORD = { id: 1, hello: 'world' };
@@ -113,4 +114,44 @@ describe( 'useEntityRecord', () => {
 		expect( widget.editedRecord ).toEqual( { hello: 'foo', id: 1 } );
 		expect( widget.edits ).toEqual( { hello: 'foo' } );
 	} );
+
+	it( 'does not resolve entity record when disabled via options', async () => {
+		triggerFetch.mockImplementation( () => TEST_RECORD );
+
+		let data;
+		const TestComponent = ( { enabled } ) => {
+			data = useEntityRecord( 'root', 'widget', 1, { enabled } );
+			return <div />;
+		};
+		const UI = ( { enabled } ) => (
+			<RegistryProvider value={ registry }>
+				<TestComponent enabled={ enabled } />
+			</RegistryProvider>
+		);
+
+		const { rerender } = render( <UI enabled={ true } /> );
+
+		// A minimum delay for a fetch request. The same delay is used again as a control.
+		await act(
+			() => new Promise( ( resolve ) => setTimeout( resolve, 0 ) )
+		);
+		expect( triggerFetch ).toHaveBeenCalledTimes( 1 );
+
+		rerender( <UI enabled={ false } /> );
+
+		expect( data ).toEqual( {
+			edit: expect.any( Function ),
+			editedRecord: {},
+			hasEdits: false,
+			edits: {},
+			record: null,
+			save: expect.any( Function ),
+		} );
+
+		// The same delay.
+		await act(
+			() => new Promise( ( resolve ) => setTimeout( resolve, 0 ) )
+		);
+		expect( triggerFetch ).toHaveBeenCalledTimes( 1 );
+	} );
 } );

package/src/hooks/use-entity-record.ts

@@ -56,6 +56,8 @@ export interface Options {
 	enabled: boolean;
 }
 
+const EMPTY_OBJECT = {};
+
 /**
  * Resolves the specified entity record.
  *
@@ -167,24 +169,34 @@ export default function useEntityRecord< RecordType >(
 	);
 
 	const { editedRecord, hasEdits, edits } = useSelect(
-		( select ) => ( {
-			editedRecord: select( coreStore ).getEditedEntityRecord(
-				kind,
-				name,
-				recordId
-			),
-			hasEdits: select( coreStore ).hasEditsForEntityRecord(
-				kind,
-				name,
-				recordId
-			),
-			edits: select( coreStore ).getEntityRecordNonTransientEdits(
-				kind,
-				name,
-				recordId
-			),
-		} ),
-		[ kind, name, recordId ]
+		( select ) => {
+			if ( ! options.enabled ) {
+				return {
+					editedRecord: EMPTY_OBJECT,
+					hasEdits: false,
+					edits: EMPTY_OBJECT,
+				};
+			}
+
+			return {
+				editedRecord: select( coreStore ).getEditedEntityRecord(
+					kind,
+					name,
+					recordId
+				),
+				hasEdits: select( coreStore ).hasEditsForEntityRecord(
+					kind,
+					name,
+					recordId
+				),
+				edits: select( coreStore ).getEntityRecordNonTransientEdits(
+					kind,
+					name,
+					recordId
+				),
+			};
+		},
+		[ kind, name, recordId, options.enabled ]
 	);
 
 	const { data: record, ...querySelectRest } = useQuerySelect(

package/src/queried-data/reducer.js

@@ -56,10 +56,10 @@ export function getMergedItemIds( itemIds, nextItemIds, page, perPage ) {
 
 	for ( let i = 0; i < size; i++ ) {
 		// Preserve existing item ID except for subset of range of next items.
+		// We need to check against the possible maximum upper boundary because
+		// a page could receive fewer than what was previously stored.
 		const isInNextItemsRange =
-			i >= nextItemIdsStartIndex &&
-			i < nextItemIdsStartIndex + nextItemIds.length;
-
+			i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + perPage;
 		mergedItemIds[ i ] = isInNextItemsRange
 			? nextItemIds[ i - nextItemIdsStartIndex ]
 			: itemIds?.[ i ];

package/src/queried-data/selectors.js

@@ -52,7 +52,9 @@ function getQueriedItemsUncached( state, query ) {
 		if ( Array.isArray( include ) && ! include.includes( itemId ) ) {
 			continue;
 		}
-
+		if ( itemId === undefined ) {
+			continue;
+		}
 		// Having a target item ID doesn't guarantee that this object has been queried.
 		if ( ! state.items[ context ]?.hasOwnProperty( itemId ) ) {
 			return null;

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

@@ -64,6 +64,17 @@ describe( 'getMergedItemIds', () => {
 
 		expect( result ).toEqual( [ 1, 3, 4 ] );
 	} );
+	it( 'should update a page properly if less items are provided than previously stored', () => {
+		let original = deepFreeze( [ 1, 2, 3 ] );
+		let result = getMergedItemIds( original, [ 1, 2 ], 1, 3 );
+
+		expect( result ).toEqual( [ 1, 2 ] );
+
+		original = deepFreeze( [ 1, 2, 3, 4, 5, 6 ] );
+		result = getMergedItemIds( original, [ 9 ], 2, 2 );
+
+		expect( result ).toEqual( [ 1, 2, 9, undefined, 5, 6 ] );
+	} );
 } );
 
 describe( 'itemIsComplete', () => {

package/src/reducer.js

@@ -238,14 +238,13 @@ function entity( entityConfig ) {
 		// Inject the entity config into the action.
 		replaceAction( ( action ) => {
 			return {
-				...action,
 				key: entityConfig.key || DEFAULT_ENTITY_KEY,
+				...action,
 			};
 		} ),
 	] )(
 		combineReducers( {
 			queriedData: queriedDataReducer,
-
 			edits: ( state = {}, action ) => {
 				switch ( action.type ) {
 					case 'RECEIVE_ITEMS':
@@ -355,6 +354,52 @@ function entity( entityConfig ) {
 
 				return state;
 			},
+
+			// Add revisions to the state tree if the post type supports it.
+			...( entityConfig?.supports?.revisions
+				? {
+						revisions: ( state = {}, action ) => {
+							// Use the same queriedDataReducer shape for revisions.
+							if ( action.type === 'RECEIVE_ITEM_REVISIONS' ) {
+								const recordKey = action.recordKey;
+								delete action.recordKey;
+								const newState = queriedDataReducer(
+									state[ recordKey ],
+									{
+										...action,
+										type: 'RECEIVE_ITEMS',
+									}
+								);
+								return {
+									...state,
+									[ recordKey ]: newState,
+								};
+							}
+
+							if ( action.type === 'REMOVE_ITEMS' ) {
+								return Object.fromEntries(
+									Object.entries( state ).filter(
+										( [ id ] ) =>
+											! action.itemIds.some(
+												( itemId ) => {
+													if (
+														Number.isInteger(
+															itemId
+														)
+													) {
+														return itemId === +id;
+													}
+													return itemId === id;
+												}
+											)
+									)
+								);
+							}
+
+							return state;
+						},
+				  }
+				: {} ),
 		} )
 	);
 }
@@ -572,6 +617,26 @@ export function themeGlobalStyleRevisions( state = {}, action ) {
 	return state;
 }
 
+/**
+ * Reducer managing the template lookup per query.
+ *
+ * @param {Record<string, string>} state  Current state.
+ * @param {Object}                 action Dispatched action.
+ *
+ * @return {Record<string, string>} Updated state.
+ */
+export function defaultTemplates( state = {}, action ) {
+	switch ( action.type ) {
+		case 'RECEIVE_DEFAULT_TEMPLATE':
+			return {
+				...state,
+				[ JSON.stringify( action.query ) ]: action.templateId,
+			};
+	}
+
+	return state;
+}
+
 export default combineReducers( {
 	terms,
 	users,
@@ -592,4 +657,5 @@ export default combineReducers( {
 	blockPatternCategories,
 	userPatternCategories,
 	navigationFallbackId,
+	defaultTemplates,
 } );

package/src/resolvers.js

@@ -244,7 +244,7 @@ export const getEntityRecords =
 
 			// If we request fields but the result doesn't contain the fields,
 			// explicitly set these fields as "undefined"
-			// that way we consider the query "fullfilled".
+			// that way we consider the query "fulfilled".
 			if ( query._fields ) {
 				records = records.map( ( record ) => {
 					query._fields.split( ',' ).forEach( ( field ) => {
@@ -322,7 +322,7 @@ export const getCurrentTheme =
 export const getThemeSupports = forwardResolver( 'getCurrentTheme' );
 
 /**
- * Requests a preview from the from the Embed API.
+ * Requests a preview from the Embed API.
  *
  * @param {string} url URL to get the preview for.
  */
@@ -707,3 +707,177 @@ export const getNavigationFallbackId =
 			] );
 		}
 	};
+
+export const getDefaultTemplateId =
+	( query ) =>
+	async ( { dispatch } ) => {
+		const template = await apiFetch( {
+			path: addQueryArgs( '/wp/v2/templates/lookup', query ),
+		} );
+		if ( template ) {
+			dispatch.receiveDefaultTemplateId( query, template.id );
+		}
+	};
+
+/**
+ * Requests an entity's revisions from the REST API.
+ *
+ * @param {string}           kind      Entity kind.
+ * @param {string}           name      Entity name.
+ * @param {number|string}    recordKey The key of the entity record whose revisions you want to fetch.
+ * @param {Object|undefined} query     Optional object of query parameters to
+ *                                     include with request. If requesting specific
+ *                                     fields, fields must always include the ID.
+ */
+export const getRevisions =
+	( kind, name, recordKey, query = {} ) =>
+	async ( { dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = configs.find(
+			( config ) => config.name === name && config.kind === kind
+		);
+
+		if (
+			! entityConfig ||
+			entityConfig?.__experimentalNoFetch ||
+			! entityConfig?.supports?.revisions
+		) {
+			return;
+		}
+
+		if ( query._fields ) {
+			// If requesting specific fields, items and query association to said
+			// records are stored by ID reference. Thus, fields must always include
+			// the ID.
+			query = {
+				...query,
+				_fields: [
+					...new Set( [
+						...( getNormalizedCommaSeparable( query._fields ) ||
+							[] ),
+						entityConfig.revisionKey || DEFAULT_ENTITY_KEY,
+					] ),
+				].join(),
+			};
+		}
+
+		const path = addQueryArgs(
+			entityConfig.getRevisionsUrl( recordKey ),
+			query
+		);
+
+		let records, meta;
+		if ( entityConfig.supportsPagination && query.per_page !== -1 ) {
+			const response = await apiFetch( { path, parse: false } );
+			records = Object.values( await response.json() );
+			meta = {
+				totalItems: parseInt( response.headers.get( 'X-WP-Total' ) ),
+			};
+		} else {
+			records = Object.values( await apiFetch( { path } ) );
+		}
+
+		// If we request fields but the result doesn't contain the fields,
+		// explicitly set these fields as "undefined"
+		// that way we consider the query "fulfilled".
+		if ( query._fields ) {
+			records = records.map( ( record ) => {
+				query._fields.split( ',' ).forEach( ( field ) => {
+					if ( ! record.hasOwnProperty( field ) ) {
+						record[ field ] = undefined;
+					}
+				} );
+
+				return record;
+			} );
+		}
+
+		dispatch.receiveRevisions(
+			kind,
+			name,
+			recordKey,
+			records,
+			query,
+			false,
+			meta
+		);
+
+		// When requesting all fields, the list of results can be used to
+		// resolve the `getRevision` selector in addition to `getRevisions`.
+		if ( ! query?._fields && ! query.context ) {
+			const key = entityConfig.key || DEFAULT_ENTITY_KEY;
+			const resolutionsArgs = records
+				.filter( ( record ) => record[ key ] )
+				.map( ( record ) => [ kind, name, recordKey, record[ key ] ] );
+
+			dispatch( {
+				type: 'START_RESOLUTIONS',
+				selectorName: 'getRevision',
+				args: resolutionsArgs,
+			} );
+			dispatch( {
+				type: 'FINISH_RESOLUTIONS',
+				selectorName: 'getRevision',
+				args: resolutionsArgs,
+			} );
+		}
+	};
+
+// Invalidate cache when a new revision is created.
+getRevisions.shouldInvalidate = ( action, kind, name, recordKey ) =>
+	action.type === 'SAVE_ENTITY_RECORD_FINISH' &&
+	name === action.name &&
+	kind === action.kind &&
+	! action.error &&
+	recordKey === action.recordId;
+
+/**
+ * Requests a specific Entity revision from the REST API.
+ *
+ * @param {string}           kind        Entity kind.
+ * @param {string}           name        Entity name.
+ * @param {number|string}    recordKey   The key of the entity record whose revisions you want to fetch.
+ * @param {number|string}    revisionKey The revision's key.
+ * @param {Object|undefined} query       Optional object of query parameters to
+ *                                       include with request. If requesting specific
+ *                                       fields, fields must always include the ID.
+ */
+export const getRevision =
+	( kind, name, recordKey, revisionKey, query ) =>
+	async ( { dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = configs.find(
+			( config ) => config.name === name && config.kind === kind
+		);
+
+		if (
+			! entityConfig ||
+			entityConfig?.__experimentalNoFetch ||
+			! entityConfig?.supports?.revisions
+		) {
+			return;
+		}
+
+		if ( query !== undefined && query._fields ) {
+			// If requesting specific fields, items and query association to said
+			// records are stored by ID reference. Thus, fields must always include
+			// the ID.
+			query = {
+				...query,
+				_fields: [
+					...new Set( [
+						...( getNormalizedCommaSeparable( query._fields ) ||
+							[] ),
+						entityConfig.revisionKey || DEFAULT_ENTITY_KEY,
+					] ),
+				].join(),
+			};
+		}
+		const path = addQueryArgs(
+			entityConfig.getRevisionsUrl( recordKey, revisionKey ),
+			query
+		);
+
+		const record = await apiFetch( { path } );
+		dispatch.receiveRevisions( kind, name, recordKey, record, query );
+	};