@wordpress/core-data 6.23.0 → 6.25.0

package/src/footnotes/index.js

@@ -1,7 +1,7 @@
 /**
  * WordPress dependencies
  */
-import { create, toHTMLString } from '@wordpress/rich-text';
+import { RichTextData, create, toHTMLString } from '@wordpress/rich-text';
 
 /**
  * Internal dependencies
@@ -53,15 +53,18 @@ export function updateFootnotesFromMeta( blocks, meta ) {
 				continue;
 			}
 
-			if ( typeof value !== 'string' ) {
+			// To do, remove support for string values?
+			if (
+				typeof value !== 'string' &&
+				! ( value instanceof RichTextData )
+			) {
 				continue;
 			}
 
-			if ( value.indexOf( 'data-fn' ) === -1 ) {
-				continue;
-			}
-
-			const richTextValue = create( { html: value } );
+			const richTextValue =
+				typeof value === 'string'
+					? RichTextData.fromHTMLString( value )
+					: value;
 
 			richTextValue.replacements.forEach( ( replacement ) => {
 				if ( replacement.type === 'core/footnote' ) {
@@ -78,7 +81,10 @@ export function updateFootnotesFromMeta( blocks, meta ) {
 				}
 			} );
 
-			attributes[ key ] = toHTMLString( { value: richTextValue } );
+			attributes[ key ] =
+				typeof value === 'string'
+					? richTextValue.toHTMLString()
+					: richTextValue;
 		}
 
 		return attributes;

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

@@ -57,7 +57,7 @@ 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 recieve less items than what was previously stored.
+		// a page could receive fewer than what was previously stored.
 		const isInNextItemsRange =
 			i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + perPage;
 		mergedItemIds[ i ] = isInNextItemsRange

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,38 @@ function entity( entityConfig ) {
 
 				return state;
 			},
+
+			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;
+			},
 		} )
 	);
 }

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.
  */
@@ -718,3 +718,183 @@ export const getDefaultTemplateId =
 			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 ) {
+			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, response;
+		const meta = {};
+		const isPaginated =
+			entityConfig.supportsPagination && query.per_page !== -1;
+		try {
+			response = await apiFetch( { path, parse: ! isPaginated } );
+		} catch ( error ) {
+			// Do nothing if our request comes back with an API error.
+			return;
+		}
+
+		if ( response ) {
+			if ( isPaginated ) {
+				records = Object.values( await response.json() );
+				meta.totalItems = parseInt(
+					response.headers.get( 'X-WP-Total' )
+				);
+			} else {
+				records = Object.values( response );
+			}
+
+			// 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 ) {
+			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
+		);
+
+		let record;
+		try {
+			record = await apiFetch( { path } );
+		} catch ( error ) {
+			// Do nothing if our request comes back with an API error.
+			return;
+		}
+
+		if ( record ) {
+			dispatch.receiveRevisions( kind, name, recordKey, record, query );
+		}
+	};

package/src/selectors.ts

@@ -62,6 +62,16 @@ interface QueriedData {
 	queries: Record< ET.Context, Record< string, Array< number > > >;
 }
 
+type RevisionRecord =
+	| Record< ET.Context, Record< number, ET.PostRevision > >
+	| Record< ET.Context, Record< number, ET.GlobalStylesRevision > >;
+
+interface RevisionsQueriedData {
+	items: RevisionRecord;
+	itemIsComplete: Record< ET.Context, Record< number, boolean > >;
+	queries: Record< ET.Context, Record< string, Array< number > > >;
+}
+
 interface EntityState< EntityRecord extends ET.EntityRecord > {
 	edits: Record< string, Partial< EntityRecord > >;
 	saving: Record<
@@ -70,6 +80,7 @@ interface EntityState< EntityRecord extends ET.EntityRecord > {
 	>;
 	deleting: Record< string, Partial< { pending: boolean; error: Error } > >;
 	queriedData: QueriedData;
+	revisions?: RevisionsQueriedData;
 }
 
 interface EntityConfig {
@@ -1342,13 +1353,20 @@ export function getUserPatternCategories(
 /**
  * Returns the revisions of the current global styles theme.
  *
- * @param state Data state.
+ * @deprecated since WordPress 6.5.0. Callers should use `select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )` instead, where `recordKey` is the id of the global styles parent post.
+ *
+ * @param      state Data state.
  *
  * @return The current global styles.
  */
 export function getCurrentThemeGlobalStylesRevisions(
 	state: State
 ): Array< object > | null {
+	deprecated( "select( 'core' ).getCurrentThemeGlobalStylesRevisions()", {
+		since: '6.5.0',
+		alternative:
+			"select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )",
+	} );
 	const currentGlobalStylesId =
 		__experimentalGetCurrentGlobalStylesId( state );
 
@@ -1373,3 +1391,103 @@ export function getDefaultTemplateId(
 ): string {
 	return state.defaultTemplates[ JSON.stringify( query ) ];
 }
+
+/**
+ * Returns an entity's revisions.
+ *
+ * @param state     State tree
+ * @param kind      Entity kind.
+ * @param name      Entity name.
+ * @param recordKey The key of the entity record whose revisions you want to fetch.
+ * @param query     Optional query. If requesting specific
+ *                  fields, fields must always include the ID. For valid query parameters see revisions schema in [the REST API Handbook](https://developer.wordpress.org/rest-api/reference/). Then see the arguments available "Retrieve a [Entity kind]".
+ *
+ * @return Record.
+ */
+export const getRevisions = (
+	state: State,
+	kind: string,
+	name: string,
+	recordKey: EntityRecordKey,
+	query?: GetRecordsHttpQuery
+): RevisionRecord[] | null => {
+	const queriedStateRevisions =
+		state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ];
+	if ( ! queriedStateRevisions ) {
+		return null;
+	}
+
+	return getQueriedItems( queriedStateRevisions, query );
+};
+
+/**
+ * Returns a single, specific revision of a parent entity.
+ *
+ * @param state       State tree
+ * @param kind        Entity kind.
+ * @param name        Entity name.
+ * @param recordKey   The key of the entity record whose revisions you want to fetch.
+ * @param revisionKey The revision's key.
+ * @param query       Optional query. If requesting specific
+ *                    fields, fields must always include the ID. For valid query parameters see revisions schema in [the REST API Handbook](https://developer.wordpress.org/rest-api/reference/). Then see the arguments available "Retrieve a [entity kind]".
+ *
+ * @return Record.
+ */
+export const getRevision = createSelector(
+	(
+		state: State,
+		kind: string,
+		name: string,
+		recordKey: EntityRecordKey,
+		revisionKey: EntityRecordKey,
+		query?: GetRecordsHttpQuery
+	): RevisionRecord | Record< PropertyKey, never > | undefined => {
+		const queriedState =
+			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[
+				recordKey
+			];
+
+		if ( ! queriedState ) {
+			return undefined;
+		}
+
+		const context = query?.context ?? 'default';
+
+		if ( query === undefined ) {
+			// If expecting a complete item, validate that completeness.
+			if ( ! queriedState.itemIsComplete[ context ]?.[ revisionKey ] ) {
+				return undefined;
+			}
+
+			return queriedState.items[ context ][ revisionKey ];
+		}
+
+		const item = queriedState.items[ context ]?.[ revisionKey ];
+		if ( item && query._fields ) {
+			const filteredItem = {};
+			const fields = getNormalizedCommaSeparable( query._fields ) ?? [];
+
+			for ( let f = 0; f < fields.length; f++ ) {
+				const field = fields[ f ].split( '.' );
+				let value = item;
+				field.forEach( ( fieldName ) => {
+					value = value?.[ fieldName ];
+				} );
+				setNestedValue( filteredItem, field, value );
+			}
+
+			return filteredItem;
+		}
+
+		return item;
+	},
+	( state: State, kind, name, recordKey, revisionKey, query ) => {
+		const context = query?.context ?? 'default';
+		return [
+			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]
+				?.items?.[ context ]?.[ revisionKey ],
+			state.entities.records?.[ kind ]?.[ name ]?.revisions?.[ recordKey ]
+				?.itemIsComplete?.[ context ]?.[ revisionKey ],
+		];
+	}
+);

package/src/test/entities.js

@@ -80,6 +80,9 @@ describe( 'getKindEntities', () => {
 				labels: {
 					singular_name: 'post',
 				},
+				supports: {
+					revisions: true,
+				},
 			},
 		];
 		const dispatch = jest.fn();
@@ -95,6 +98,12 @@ describe( 'getKindEntities', () => {
 		expect( dispatch.mock.calls[ 0 ][ 0 ].entities[ 0 ].baseURL ).toBe(
 			'/wp/v2/posts'
 		);
+		expect(
+			dispatch.mock.calls[ 0 ][ 0 ].entities[ 0 ].getRevisionsUrl( 1 )
+		).toBe( '/wp/v2/posts/1/revisions' );
+		expect(
+			dispatch.mock.calls[ 0 ][ 0 ].entities[ 0 ].getRevisionsUrl( 1, 2 )
+		).toBe( '/wp/v2/posts/1/revisions/2' );
 	} );
 } );