@wordpress/core-data 4.0.1 → 4.0.5

package/src/reducer.js

@@ -15,7 +15,6 @@ import isShallowEqual from '@wordpress/is-shallow-equal';
 import { ifMatchingAction, replaceAction } from './utils';
 import { reducer as queriedDataReducer } from './queried-data';
 import { defaultEntities, DEFAULT_ENTITY_KEY } from './entities';
-import { reducer as locksReducer } from './locks';
 
 /**
  * Reducer managing terms state. Keyed by taxonomy slug, the value is either
@@ -121,39 +120,36 @@ export function currentTheme( state = undefined, action ) {
 }
 
 /**
- * Reducer managing installed themes.
+ * Reducer managing the current global styles id.
  *
- * @param {Object} state  Current state.
+ * @param {string} state  Current state.
  * @param {Object} action Dispatched action.
  *
- * @return {Object} Updated state.
+ * @return {string} Updated state.
  */
-export function themes( state = {}, action ) {
+export function currentGlobalStylesId( state = undefined, action ) {
 	switch ( action.type ) {
-		case 'RECEIVE_CURRENT_THEME':
-			return {
-				...state,
-				[ action.currentTheme.stylesheet ]: action.currentTheme,
-			};
+		case 'RECEIVE_CURRENT_GLOBAL_STYLES_ID':
+			return action.id;
 	}
 
 	return state;
 }
 
 /**
- * Reducer managing theme supports data.
+ * Reducer managing the theme base global styles.
  *
- * @param {Object} state  Current state.
+ * @param {string} state  Current state.
  * @param {Object} action Dispatched action.
  *
- * @return {Object} Updated state.
+ * @return {string} Updated state.
  */
-export function themeSupports( state = {}, action ) {
+export function themeBaseGlobalStyles( state = {}, action ) {
 	switch ( action.type ) {
-		case 'RECEIVE_THEME_SUPPORTS':
+		case 'RECEIVE_THEME_GLOBAL_STYLES':
 			return {
 				...state,
-				...action.themeSupports,
+				[ action.stylesheet ]: action.globalStyles,
 			};
 	}
 
@@ -571,14 +567,13 @@ export default combineReducers( {
 	terms,
 	users,
 	currentTheme,
+	currentGlobalStylesId,
 	currentUser,
+	themeBaseGlobalStyles,
 	taxonomies,
-	themes,
-	themeSupports,
 	entities,
 	undo,
 	embedPreviews,
 	userPermissions,
 	autosaves,
-	locks: locksReducer,
 } );

package/src/resolvers.js

@@ -7,33 +7,14 @@ import { find, includes, get, hasIn, compact, uniq } from 'lodash';
  * WordPress dependencies
  */
 import { addQueryArgs } from '@wordpress/url';
-import { controls } from '@wordpress/data';
-import { apiFetch } from '@wordpress/data-controls';
-/**
- * Internal dependencies
- */
-import { regularFetch } from './controls';
-import { STORE_NAME } from './name';
+import apiFetch from '@wordpress/api-fetch';
 
 /**
  * Internal dependencies
  */
-import {
-	receiveUserQuery,
-	receiveCurrentTheme,
-	receiveCurrentUser,
-	receiveEntityRecords,
-	receiveThemeSupports,
-	receiveEmbedPreview,
-	receiveUserPermission,
-	receiveAutosaves,
-} from './actions';
+import { STORE_NAME } from './name';
 import { getKindEntities, DEFAULT_ENTITY_KEY } from './entities';
-import { ifNotResolved, getNormalizedCommaSeparable } from './utils';
-import {
-	__unstableAcquireStoreLock,
-	__unstableReleaseStoreLock,
-} from './locks';
+import { forwardResolver, getNormalizedCommaSeparable } from './utils';
 
 /**
  * Requests authors from the REST API.
@@ -41,22 +22,22 @@ import {
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export function* getAuthors( query ) {
+export const getAuthors = ( query ) => async ( { dispatch } ) => {
 	const path = addQueryArgs(
 		'/wp/v2/users/?who=authors&per_page=100',
 		query
 	);
-	const users = yield apiFetch( { path } );
-	yield receiveUserQuery( path, users );
-}
+	const users = await apiFetch( { path } );
+	dispatch.receiveUserQuery( path, users );
+};
 
 /**
  * Requests the current user from the REST API.
  */
-export function* getCurrentUser() {
-	const currentUser = yield apiFetch( { path: '/wp/v2/users/me' } );
-	yield receiveCurrentUser( currentUser );
-}
+export const getCurrentUser = () => async ( { dispatch } ) => {
+	const currentUser = await apiFetch( { path: '/wp/v2/users/me' } );
+	dispatch.receiveCurrentUser( currentUser );
+};
 
 /**
  * Requests an entity's record from the REST API.
@@ -67,18 +48,22 @@ export function* getCurrentUser() {
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export function* getEntityRecord( kind, name, key = '', query ) {
-	const entities = yield getKindEntities( kind );
+export const getEntityRecord = ( kind, name, key = '', query ) => async ( {
+	select,
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
-	if ( ! entity ) {
+	if ( ! entity || entity?.__experimentalNoFetch ) {
 		return;
 	}
 
-	const lock = yield* __unstableAcquireStoreLock(
+	const lock = await dispatch.__unstableAcquireStoreLock(
 		STORE_NAME,
 		[ 'entities', 'data', kind, name, key ],
 		{ exclusive: false }
 	);
+
 	try {
 		if ( query !== undefined && query._fields ) {
 			// If requesting specific fields, items and query association to said
@@ -100,7 +85,7 @@ export function* getEntityRecord( kind, name, key = '', query ) {
 		// for how the request is made to the REST API.
 
 		// eslint-disable-next-line @wordpress/no-unused-vars-before-return
-		const path = addQueryArgs( entity.baseURL + '/' + key, {
+		const path = addQueryArgs( entity.baseURL + ( key ? '/' + key : '' ), {
 			...entity.baseURLParams,
 			...query,
 		} );
@@ -111,43 +96,31 @@ export function* getEntityRecord( kind, name, key = '', query ) {
 			// The resolution cache won't consider query as reusable based on the
 			// fields, so it's tested here, prior to initiating the REST request,
 			// and without causing `getEntityRecords` resolution to occur.
-			const hasRecords = yield controls.select(
-				STORE_NAME,
-				'hasEntityRecords',
-				kind,
-				name,
-				query
-			);
+			const hasRecords = select.hasEntityRecords( kind, name, query );
 			if ( hasRecords ) {
 				return;
 			}
 		}
 
-		const record = yield apiFetch( { path } );
-		yield receiveEntityRecords( kind, name, record, query );
+		const record = await apiFetch( { path } );
+		dispatch.receiveEntityRecords( kind, name, record, query );
 	} catch ( error ) {
 		// We need a way to handle and access REST API errors in state
 		// Until then, catching the error ensures the resolver is marked as resolved.
 	} finally {
-		yield* __unstableReleaseStoreLock( lock );
+		dispatch.__unstableReleaseStoreLock( lock );
 	}
-}
+};
 
 /**
  * Requests an entity's record from the REST API.
  */
-export const getRawEntityRecord = ifNotResolved(
-	getEntityRecord,
-	'getEntityRecord'
-);
+export const getRawEntityRecord = forwardResolver( 'getEntityRecord' );
 
 /**
  * Requests an entity's record from the REST API.
  */
-export const getEditedEntityRecord = ifNotResolved(
-	getRawEntityRecord,
-	'getRawEntityRecord'
-);
+export const getEditedEntityRecord = forwardResolver( 'getEntityRecord' );
 
 /**
  * Requests the entity's records from the REST API.
@@ -156,18 +129,21 @@ export const getEditedEntityRecord = ifNotResolved(
  * @param {string}  name  Entity name.
  * @param {Object?} query Query Object.
  */
-export function* getEntityRecords( kind, name, query = {} ) {
-	const entities = yield getKindEntities( kind );
+export const getEntityRecords = ( kind, name, query = {} ) => async ( {
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
-	if ( ! entity ) {
+	if ( ! entity || entity?.__experimentalNoFetch ) {
 		return;
 	}
 
-	const lock = yield* __unstableAcquireStoreLock(
+	const lock = await dispatch.__unstableAcquireStoreLock(
 		STORE_NAME,
 		[ 'entities', 'data', kind, name ],
 		{ exclusive: false }
 	);
+
 	try {
 		if ( query._fields ) {
 			// If requesting specific fields, items and query association to said
@@ -187,7 +163,7 @@ export function* getEntityRecords( kind, name, query = {} ) {
 			...query,
 		} );
 
-		let records = Object.values( yield apiFetch( { path } ) );
+		let records = Object.values( await apiFetch( { path } ) );
 		// If we request fields but the result doesn't contain the fields,
 		// explicitely set these fields as "undefined"
 		// that way we consider the query "fullfilled".
@@ -203,7 +179,8 @@ export function* getEntityRecords( kind, name, query = {} ) {
 			} );
 		}
 
-		yield receiveEntityRecords( kind, name, records, query );
+		dispatch.receiveEntityRecords( kind, name, records, query );
+
 		// When requesting all fields, the list of results can be used to
 		// resolve the `getEntityRecord` selector in addition to `getEntityRecords`.
 		// See https://github.com/WordPress/gutenberg/pull/26575
@@ -213,21 +190,21 @@ export function* getEntityRecords( kind, name, query = {} ) {
 				.filter( ( record ) => record[ key ] )
 				.map( ( record ) => [ kind, name, record[ key ] ] );
 
-			yield {
+			dispatch( {
 				type: 'START_RESOLUTIONS',
 				selectorName: 'getEntityRecord',
 				args: resolutionsArgs,
-			};
-			yield {
+			} );
+			dispatch( {
 				type: 'FINISH_RESOLUTIONS',
 				selectorName: 'getEntityRecord',
 				args: resolutionsArgs,
-			};
+			} );
 		}
 	} finally {
-		yield* __unstableReleaseStoreLock( lock );
+		dispatch.__unstableReleaseStoreLock( lock );
 	}
-}
+};
 
 getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 	return (
@@ -241,39 +218,37 @@ getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 /**
  * Requests the current theme.
  */
-export function* getCurrentTheme() {
-	const activeThemes = yield apiFetch( {
-		path: '/wp/v2/themes?status=active',
-	} );
-	yield receiveCurrentTheme( activeThemes[ 0 ] );
-}
+export const getCurrentTheme = () => async ( { dispatch, resolveSelect } ) => {
+	const activeThemes = await resolveSelect.getEntityRecords(
+		'root',
+		'theme',
+		{ status: 'active' }
+	);
+
+	dispatch.receiveCurrentTheme( activeThemes[ 0 ] );
+};
 
 /**
  * Requests theme supports data from the index.
  */
-export function* getThemeSupports() {
-	const activeThemes = yield apiFetch( {
-		path: '/wp/v2/themes?status=active',
-	} );
-	yield receiveThemeSupports( activeThemes[ 0 ].theme_supports );
-}
+export const getThemeSupports = forwardResolver( 'getCurrentTheme' );
 
 /**
  * Requests a preview from the from the Embed API.
  *
  * @param {string} url URL to get the preview for.
  */
-export function* getEmbedPreview( url ) {
+export const getEmbedPreview = ( url ) => async ( { dispatch } ) => {
 	try {
-		const embedProxyResponse = yield apiFetch( {
+		const embedProxyResponse = await apiFetch( {
 			path: addQueryArgs( '/oembed/1.0/proxy', { url } ),
 		} );
-		yield receiveEmbedPreview( url, embedProxyResponse );
+		dispatch.receiveEmbedPreview( url, embedProxyResponse );
 	} catch ( error ) {
 		// Embed API 404s if the URL cannot be embedded, so we have to catch the error from the apiRequest here.
-		yield receiveEmbedPreview( url, false );
+		dispatch.receiveEmbedPreview( url, false );
 	}
-}
+};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -284,7 +259,7 @@ export function* getEmbedPreview( url ) {
  * @param {string}  resource REST resource to check, e.g. 'media' or 'posts'.
  * @param {?string} id       ID of the rest resource to check.
  */
-export function* canUser( action, resource, id ) {
+export const canUser = ( action, resource, id ) => async ( { dispatch } ) => {
 	const methods = {
 		create: 'POST',
 		read: 'GET',
@@ -301,7 +276,7 @@ export function* canUser( action, resource, id ) {
 
 	let response;
 	try {
-		response = yield apiFetch( {
+		response = await apiFetch( {
 			path,
 			// Ideally this would always be an OPTIONS request, but unfortunately there's
 			// a bug in the REST API which causes the Allow header to not be sent on
@@ -329,8 +304,8 @@ export function* canUser( action, resource, id ) {
 
 	const key = compact( [ action, resource, id ] ).join( '/' );
 	const isAllowed = includes( allowHeader, method );
-	yield receiveUserPermission( key, isAllowed );
-}
+	dispatch.receiveUserPermission( key, isAllowed );
+};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -340,16 +315,18 @@ export function* canUser( action, resource, id ) {
  * @param {string} name     Entity name.
  * @param {string} recordId Record's id.
  */
-export function* canUserEditEntityRecord( kind, name, recordId ) {
-	const entities = yield getKindEntities( kind );
+export const canUserEditEntityRecord = ( kind, name, recordId ) => async ( {
+	dispatch,
+} ) => {
+	const entities = await dispatch( getKindEntities( kind ) );
 	const entity = find( entities, { kind, name } );
 	if ( ! entity ) {
 		return;
 	}
 
 	const resource = entity.__unstable_rest_base;
-	yield canUser( 'update', resource, recordId );
-}
+	await dispatch( canUser( 'update', resource, recordId ) );
+};
 
 /**
  * Request autosave data from the REST API.
@@ -357,20 +334,19 @@ export function* canUserEditEntityRecord( kind, name, recordId ) {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-export function* getAutosaves( postType, postId ) {
-	const { rest_base: restBase } = yield controls.resolveSelect(
-		STORE_NAME,
-		'getPostType',
-		postType
-	);
-	const autosaves = yield apiFetch( {
+export const getAutosaves = ( postType, postId ) => async ( {
+	dispatch,
+	resolveSelect,
+} ) => {
+	const { rest_base: restBase } = await resolveSelect.getPostType( postType );
+	const autosaves = await apiFetch( {
 		path: `/wp/v2/${ restBase }/${ postId }/autosaves?context=edit`,
 	} );
 
 	if ( autosaves && autosaves.length ) {
-		yield receiveAutosaves( postId, autosaves );
+		dispatch.receiveAutosaves( postId, autosaves );
 	}
-}
+};
 
 /**
  * Request autosave data from the REST API.
@@ -381,31 +357,30 @@ export function* getAutosaves( postType, postId ) {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-export function* getAutosave( postType, postId ) {
-	yield controls.resolveSelect(
-		STORE_NAME,
-		'getAutosaves',
-		postType,
-		postId
-	);
-}
+export const getAutosave = ( postType, postId ) => async ( {
+	resolveSelect,
+} ) => {
+	await resolveSelect.getAutosaves( postType, postId );
+};
 
 /**
  * Retrieve the frontend template used for a given link.
  *
  * @param {string} link Link.
  */
-export function* __experimentalGetTemplateForLink( link ) {
+export const __experimentalGetTemplateForLink = ( link ) => async ( {
+	dispatch,
+	resolveSelect,
+} ) => {
 	// Ideally this should be using an apiFetch call
 	// We could potentially do so by adding a "filter" to the `wp_template` end point.
 	// Also it seems the returned object is not a regular REST API post type.
 	let template;
 	try {
-		template = yield regularFetch(
-			addQueryArgs( link, {
-				'_wp-find-template': true,
-			} )
-		);
+		template = await window
+			.fetch( addQueryArgs( link, { '_wp-find-template': true } ) )
+			.then( ( res ) => res.json() )
+			.then( ( { data } ) => data );
 	} catch ( e ) {
 		// For non-FSE themes, it is possible that this request returns an error.
 	}
@@ -414,21 +389,18 @@ export function* __experimentalGetTemplateForLink( link ) {
 		return;
 	}
 
-	yield getEntityRecord( 'postType', 'wp_template', template.id );
-	const record = yield controls.select(
-		STORE_NAME,
-		'getEntityRecord',
+	const record = await resolveSelect.getEntityRecord(
 		'postType',
 		'wp_template',
 		template.id
 	);
 
 	if ( record ) {
-		yield receiveEntityRecords( 'postType', 'wp_template', [ record ], {
+		dispatch.receiveEntityRecords( 'postType', 'wp_template', [ record ], {
 			'find-template': link,
 		} );
 	}
-}
+};
 
 __experimentalGetTemplateForLink.shouldInvalidate = ( action ) => {
 	return (
@@ -438,3 +410,43 @@ __experimentalGetTemplateForLink.shouldInvalidate = ( action ) => {
 		action.name === 'wp_template'
 	);
 };
+
+export const __experimentalGetCurrentGlobalStylesId = () => async ( {
+	dispatch,
+	resolveSelect,
+} ) => {
+	const activeThemes = await resolveSelect.getEntityRecords(
+		'root',
+		'theme',
+		{ status: 'active' }
+	);
+	const globalStylesURL = get( activeThemes, [
+		0,
+		'_links',
+		'wp:user-global-styles',
+		0,
+		'href',
+	] );
+	if ( globalStylesURL ) {
+		const globalStylesObject = await apiFetch( {
+			url: globalStylesURL,
+		} );
+		dispatch.__experimentalReceiveCurrentGlobalStylesId(
+			globalStylesObject.id
+		);
+	}
+};
+
+export const __experimentalGetCurrentThemeBaseGlobalStyles = () => async ( {
+	resolveSelect,
+	dispatch,
+} ) => {
+	const currentTheme = await resolveSelect.getCurrentTheme();
+	const themeGlobalStyles = await apiFetch( {
+		path: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }`,
+	} );
+	await dispatch.__experimentalReceiveThemeBaseGlobalStyles(
+		currentTheme.stylesheet,
+		themeGlobalStyles
+	);
+};