@wordpress/core-data 4.3.0 → 4.4.0

package/src/fetch/test/__experimental-fetch-link-suggestions.js

@@ -70,6 +70,18 @@ jest.mock( '@wordpress/api-fetch', () =>
 						subtype: 'page',
 					},
 				] );
+			case '/wp/v2/media?search=&per_page=20':
+				return Promise.resolve( [
+					{
+						id: 54,
+						title: {
+							rendered: 'Some Test Media Title',
+						},
+						type: 'attachment',
+						source_url:
+							'http://localhost:8888/wp-content/uploads/2022/03/test-pdf.pdf',
+					},
+				] );
 			default:
 				return Promise.resolve( [
 					{
@@ -154,7 +166,25 @@ describe( 'fetchLinkSuggestions', () => {
 			{ disablePostFormats: true }
 		).then( ( suggestions ) => expect( suggestions ).toEqual( [] ) );
 	} );
-	it( 'returns suggestions from post, term, and post-format', () => {
+
+	it( 'filters suggestions by attachment', () => {
+		return fetchLinkSuggestions( '', {
+			type: 'attachment',
+		} ).then( ( suggestions ) =>
+			expect( suggestions ).toEqual( [
+				{
+					id: 54,
+					title: 'Some Test Media Title',
+					url:
+						'http://localhost:8888/wp-content/uploads/2022/03/test-pdf.pdf',
+					type: 'attachment',
+					kind: 'media',
+				},
+			] )
+		);
+	} );
+
+	it( 'returns suggestions from post, term, post-format and media', () => {
 		return fetchLinkSuggestions( '', {} ).then( ( suggestions ) =>
 			expect( suggestions ).toEqual( [
 				{
@@ -192,6 +222,14 @@ describe( 'fetchLinkSuggestions', () => {
 					type: 'post-format',
 					kind: 'taxonomy',
 				},
+				{
+					id: 54,
+					title: 'Some Test Media Title',
+					url:
+						'http://localhost:8888/wp-content/uploads/2022/03/test-pdf.pdf',
+					type: 'attachment',
+					kind: 'media',
+				},
 			] )
 		);
 	} );

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

@@ -30,10 +30,10 @@ interface Options {
 /**
  * Resolves the specified entity record.
  *
- * @param  kind                                 Kind of the requested entity.
- * @param  name                                 Name of the requested  entity.
- * @param  recordId                             Record ID of the requested entity.
- * @param  options                              Hook options.
+ * @param  kind                   Kind of the requested entity.
+ * @param  name                   Name of the requested  entity.
+ * @param  recordId               Record ID of the requested entity.
+ * @param  options                Hook options.
  * @param  [options.enabled=true] Whether to run the query or short-circuit and return null. Defaults to true.
  * @example
  * ```js

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

@@ -40,10 +40,10 @@ interface Options {
 /**
  * Resolves the specified entity records.
  *
- * @param  kind                                 Kind of the requested entities.
- * @param  name                                 Name of the requested entities.
- * @param  queryArgs                            HTTP query for the requested entities.
- * @param  options                              Hook options.
+ * @param  kind      Kind of the requested entities.
+ * @param  name      Name of the requested entities.
+ * @param  queryArgs HTTP query for the requested entities.
+ * @param  options   Hook options.
  * @example
  * ```js
  * import { useEntityRecord } from '@wordpress/core-data';

package/src/hooks/use-query-select.ts

@@ -17,9 +17,9 @@ export const META_SELECTORS = [
 	'getCachedResolvers',
 ];
 
-interface QuerySelectResponse {
+interface QuerySelectResponse< Data > {
 	/** the requested selector return value */
-	data: Object;
+	data: Data;
 
 	/** is the record still being resolved? Via the `getIsResolving` meta-selector */
 	isResolving: boolean;
@@ -78,9 +78,14 @@ export default function __experimentalUseQuerySelect( mapQuerySelect, deps ) {
 	}, deps );
 }
 
-type QuerySelector = ( ...args ) => QuerySelectResponse;
 interface EnrichedSelectors {
-	[ key: string ]: QuerySelector;
+	< Selectors extends Record< string, ( ...args: any[] ) => any > >(
+		selectors: Selectors
+	): {
+		[ Selector in keyof Selectors ]: (
+			...args: Parameters< Selectors[ Selector ] >
+		) => QuerySelectResponse< ReturnType< Selectors[ Selector ] > >;
+	};
 }
 
 /**
@@ -90,14 +95,14 @@ interface EnrichedSelectors {
  * @param {Object} selectors Selectors to enrich
  * @return {EnrichedSelectors} Enriched selectors
  */
-const enrichSelectors = memoize( ( selectors ) => {
+const enrichSelectors = memoize( ( ( selectors ) => {
 	const resolvers = {};
 	for ( const selectorName in selectors ) {
 		if ( META_SELECTORS.includes( selectorName ) ) {
 			continue;
 		}
 		Object.defineProperty( resolvers, selectorName, {
-			get: () => ( ...args ) => {
+			get: () => ( ...args: unknown[] ) => {
 				const { getIsResolving, hasFinishedResolution } = selectors;
 				const isResolving = !! getIsResolving( selectorName, args );
 				const hasResolved =
@@ -128,4 +133,4 @@ const enrichSelectors = memoize( ( selectors ) => {
 		} );
 	}
 	return resolvers;
-} );
+} ) as EnrichedSelectors );

package/src/reducer.js

@@ -16,6 +16,8 @@ import { ifMatchingAction, replaceAction } from './utils';
 import { reducer as queriedDataReducer } from './queried-data';
 import { rootEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 
+/** @typedef {import('./types').AnyFunction} AnyFunction */
+
 /**
  * Reducer managing terms state. Keyed by taxonomy slug, the value is either
  * undefined (if no request has been made for given taxonomy), null (if a
@@ -185,7 +187,7 @@ export function themeGlobalStyleVariations( state = {}, action ) {
  *
  * @param {Object} entityConfig Entity config.
  *
- * @return {Function} Reducer.
+ * @return {AnyFunction} Reducer.
  */
 function entity( entityConfig ) {
 	return flowRight( [
@@ -398,16 +400,32 @@ export const entities = ( state = {}, action ) => {
 };
 
 /**
- * Reducer keeping track of entity edit undo history.
+ * @typedef {Object} UndoStateMeta
  *
- * @param {Object} state  Current state.
- * @param {Object} action Dispatched action.
+ * @property {number} offset          Where in the undo stack we are.
+ * @property {Object} [flattenedUndo] Flattened form of undo stack.
+ */
+
+/** @typedef {Array<Object> & UndoStateMeta} UndoState */
+
+/**
+ * @type {UndoState}
  *
- * @return {Object} Updated state.
+ * @todo Given how we use this we might want to make a custom class for it.
  */
-const UNDO_INITIAL_STATE = [];
-UNDO_INITIAL_STATE.offset = 0;
+const UNDO_INITIAL_STATE = Object.assign( [], { offset: 0 } );
+
+/** @type {Object} */
 let lastEditAction;
+
+/**
+ * Reducer keeping track of entity edit undo history.
+ *
+ * @param {UndoState} state  Current state.
+ * @param {Object}    action Dispatched action.
+ *
+ * @return {UndoState} Updated state.
+ */
 export function undo( state = UNDO_INITIAL_STATE, action ) {
 	switch ( action.type ) {
 		case 'EDIT_ENTITY_RECORD':
@@ -439,8 +457,11 @@ export function undo( state = UNDO_INITIAL_STATE, action ) {
 				}
 			}
 
+			/** @type {UndoState} */
 			let nextState;
+
 			if ( isUndoOrRedo ) {
+				// @ts-ignore we might consider using Object.assign({}, state)
 				nextState = [ ...state ];
 				nextState.offset =
 					state.offset + ( action.meta.isUndo ? -1 : 1 );
@@ -480,6 +501,7 @@ export function undo( state = UNDO_INITIAL_STATE, action ) {
 					( key ) => ! action.transientEdits[ key ]
 				)
 			) {
+				// @ts-ignore we might consider using Object.assign({}, state)
 				nextState = [ ...state ];
 				nextState.flattenedUndo = {
 					...state.flattenedUndo,
@@ -491,6 +513,7 @@ export function undo( state = UNDO_INITIAL_STATE, action ) {
 
 			// Clear potential redos, because this only supports linear history.
 			nextState =
+				// @ts-ignore this needs additional cleanup, probably involving code-level changes
 				nextState || state.slice( 0, state.offset || undefined );
 			nextState.offset = nextState.offset || 0;
 			nextState.pop();
@@ -592,6 +615,24 @@ export function autosaves( state = {}, action ) {
 	return state;
 }
 
+export function blockPatterns( state = [], action ) {
+	switch ( action.type ) {
+		case 'RECEIVE_BLOCK_PATTERNS':
+			return action.patterns;
+	}
+
+	return state;
+}
+
+export function blockPatternCategories( state = [], action ) {
+	switch ( action.type ) {
+		case 'RECEIVE_BLOCK_PATTERN_CATEGORIES':
+			return action.categories;
+	}
+
+	return state;
+}
+
 export default combineReducers( {
 	terms,
 	users,
@@ -606,4 +647,6 @@ export default combineReducers( {
 	embedPreviews,
 	userPermissions,
 	autosaves,
+	blockPatterns,
+	blockPatternCategories,
 } );

package/src/resolvers.js

@@ -453,3 +453,17 @@ export const __experimentalGetCurrentThemeGlobalStylesVariations = () => async (
 		variations
 	);
 };
+
+export const getBlockPatterns = () => async ( { dispatch } ) => {
+	const patterns = await apiFetch( {
+		path: '/__experimental/block-patterns/patterns',
+	} );
+	dispatch( { type: 'RECEIVE_BLOCK_PATTERNS', patterns } );
+};
+
+export const getBlockPatternCategories = () => async ( { dispatch } ) => {
+	const categories = await apiFetch( {
+		path: '/__experimental/block-patterns/categories',
+	} );
+	dispatch( { type: 'RECEIVE_BLOCK_PATTERN_CATEGORIES', categories } );
+};

package/src/{selectors.js → selectors.ts}

@@ -501,10 +501,10 @@ export const getEntityRecordNonTransientEdits = createSelector(
  * Returns true if the specified entity record has edits,
  * and false otherwise.
  *
- * @param {Object} state    State tree.
- * @param {string} kind     Entity kind.
- * @param {string} name     Entity name.
- * @param {number} recordId Record ID.
+ * @param {Object}        state    State tree.
+ * @param {string}        kind     Entity kind.
+ * @param {string}        name     Entity name.
+ * @param {number|string} recordId Record ID.
  *
  * @return {boolean} Whether the entity record has edits or not.
  */
@@ -962,3 +962,25 @@ export function __experimentalGetCurrentThemeGlobalStylesVariations( state ) {
 	}
 	return state.themeGlobalStyleVariations[ currentTheme.stylesheet ];
 }
+
+/**
+ * Retrieve the list of registered block patterns.
+ *
+ * @param {Object} state Data state.
+ *
+ * @return {Array} Block pattern list.
+ */
+export function getBlockPatterns( state ) {
+	return state.blockPatterns;
+}
+
+/**
+ * Retrieve the list of registered block pattern categories.
+ *
+ * @param {Object} state Data state.
+ *
+ * @return {Array} Block pattern category list.
+ */
+export function getBlockPatternCategories( state ) {
+	return state.blockPatternCategories;
+}

package/src/types.ts

@@ -0,0 +1,3 @@
+export interface AnyFunction {
+	( ...args: any[] ): any;
+}

package/src/utils/if-matching-action.js

@@ -1,11 +1,13 @@
+/** @typedef {import('../types').AnyFunction} AnyFunction */
+
 /**
  * A higher-order reducer creator which invokes the original reducer only if
  * the dispatching action matches the given predicate, **OR** if state is
  * initializing (undefined).
  *
- * @param {Function} isMatch Function predicate for allowing reducer call.
+ * @param {AnyFunction} isMatch Function predicate for allowing reducer call.
  *
- * @return {Function} Higher-order reducer.
+ * @return {AnyFunction} Higher-order reducer.
  */
 const ifMatchingAction = ( isMatch ) => ( reducer ) => ( state, action ) => {
 	if ( state === undefined || isMatch( action ) ) {

package/src/utils/on-sub-key.js

@@ -1,10 +1,12 @@
+/** @typedef {import('../types').AnyFunction} AnyFunction */
+
 /**
  * Higher-order reducer creator which creates a combined reducer object, keyed
  * by a property on the action object.
  *
  * @param {string} actionProperty Action property by which to key object.
  *
- * @return {Function} Higher-order reducer.
+ * @return {AnyFunction} Higher-order reducer.
  */
 export const onSubKey = ( actionProperty ) => ( reducer ) => (
 	state = {},

package/src/utils/replace-action.js

@@ -1,10 +1,12 @@
+/** @typedef {import('../types').AnyFunction} AnyFunction */
+
 /**
  * Higher-order reducer creator which substitutes the action object before
  * passing to the original reducer.
  *
- * @param {Function} replacer Function mapping original action to replacement.
+ * @param {AnyFunction} replacer Function mapping original action to replacement.
  *
- * @return {Function} Higher-order reducer.
+ * @return {AnyFunction} Higher-order reducer.
  */
 const replaceAction = ( replacer ) => ( reducer ) => ( state, action ) => {
 	return reducer( state, replacer( action ) );