@wordpress/core-data 4.7.0 → 4.10.0

package/src/resolvers.js

@@ -1,7 +1,16 @@
 /**
  * External dependencies
  */
-import { find, includes, get, compact, uniq, map, mapKeys } from 'lodash';
+import {
+	camelCase,
+	compact,
+	find,
+	get,
+	includes,
+	map,
+	mapKeys,
+	uniq,
+} from 'lodash';
 
 /**
  * WordPress dependencies
@@ -22,22 +31,26 @@ import { forwardResolver, getNormalizedCommaSeparable } from './utils';
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export const getAuthors = ( query ) => async ( { dispatch } ) => {
-	const path = addQueryArgs(
-		'/wp/v2/users/?who=authors&per_page=100',
-		query
-	);
-	const users = await apiFetch( { path } );
-	dispatch.receiveUserQuery( path, users );
-};
+export const getAuthors =
+	( query ) =>
+	async ( { dispatch } ) => {
+		const path = addQueryArgs(
+			'/wp/v2/users/?who=authors&per_page=100',
+			query
+		);
+		const users = await apiFetch( { path } );
+		dispatch.receiveUserQuery( path, users );
+	};
 
 /**
  * Requests the current user from the REST API.
  */
-export const getCurrentUser = () => async ( { dispatch } ) => {
-	const currentUser = await apiFetch( { path: '/wp/v2/users/me' } );
-	dispatch.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.
@@ -48,69 +61,69 @@ export const getCurrentUser = () => async ( { dispatch } ) => {
  * @param {Object|undefined} query Optional object of query parameters to
  *                                 include with request.
  */
-export const getEntityRecord = ( kind, name, key = '', query ) => async ( {
-	select,
-	dispatch,
-} ) => {
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, name } );
-	if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
-		return;
-	}
-
-	const lock = await dispatch.__unstableAcquireStoreLock(
-		STORE_NAME,
-		[ 'entities', 'records', kind, name, key ],
-		{ exclusive: false }
-	);
-
-	try {
-		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: uniq( [
-					...( getNormalizedCommaSeparable( query._fields ) || [] ),
-					entityConfig.key || DEFAULT_ENTITY_KEY,
-				] ).join(),
-			};
+export const getEntityRecord =
+	( kind, name, key = '', query ) =>
+	async ( { select, dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, name } );
+		if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
+			return;
 		}
 
-		// Disable reason: While true that an early return could leave `path`
-		// unused, it's important that path is derived using the query prior to
-		// additional query modifications in the condition below, since those
-		// modifications are relevant to how the data is tracked in state, and not
-		// for how the request is made to the REST API.
-
-		// eslint-disable-next-line @wordpress/no-unused-vars-before-return
-		const path = addQueryArgs(
-			entityConfig.baseURL + ( key ? '/' + key : '' ),
-			{
-				...entityConfig.baseURLParams,
-				...query,
-			}
+		const lock = await dispatch.__unstableAcquireStoreLock(
+			STORE_NAME,
+			[ 'entities', 'records', kind, name, key ],
+			{ exclusive: false }
 		);
 
-		if ( query !== undefined ) {
-			query = { ...query, include: [ key ] };
+		try {
+			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: uniq( [
+						...( getNormalizedCommaSeparable( query._fields ) ||
+							[] ),
+						entityConfig.key || DEFAULT_ENTITY_KEY,
+					] ).join(),
+				};
+			}
 
-			// 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 = select.hasEntityRecords( kind, name, query );
-			if ( hasRecords ) {
-				return;
+			// Disable reason: While true that an early return could leave `path`
+			// unused, it's important that path is derived using the query prior to
+			// additional query modifications in the condition below, since those
+			// modifications are relevant to how the data is tracked in state, and not
+			// for how the request is made to the REST API.
+
+			// eslint-disable-next-line @wordpress/no-unused-vars-before-return
+			const path = addQueryArgs(
+				entityConfig.baseURL + ( key ? '/' + key : '' ),
+				{
+					...entityConfig.baseURLParams,
+					...query,
+				}
+			);
+
+			if ( query !== undefined ) {
+				query = { ...query, include: [ key ] };
+
+				// 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 = select.hasEntityRecords( kind, name, query );
+				if ( hasRecords ) {
+					return;
+				}
 			}
-		}
 
-		const record = await apiFetch( { path } );
-		dispatch.receiveEntityRecords( kind, name, record, query );
-	} finally {
-		dispatch.__unstableReleaseStoreLock( lock );
-	}
-};
+			const record = await apiFetch( { path } );
+			dispatch.receiveEntityRecords( kind, name, record, query );
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
+		}
+	};
 
 /**
  * Requests an entity's record from the REST API.
@@ -129,82 +142,83 @@ export const getEditedEntityRecord = forwardResolver( 'getEntityRecord' );
  * @param {string}  name  Entity name.
  * @param {Object?} query Query Object.
  */
-export const getEntityRecords = ( kind, name, query = {} ) => async ( {
-	dispatch,
-} ) => {
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, name } );
-	if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
-		return;
-	}
-
-	const lock = await dispatch.__unstableAcquireStoreLock(
-		STORE_NAME,
-		[ 'entities', 'records', kind, name ],
-		{ exclusive: false }
-	);
-
-	try {
-		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: uniq( [
-					...( getNormalizedCommaSeparable( query._fields ) || [] ),
-					entityConfig.key || DEFAULT_ENTITY_KEY,
-				] ).join(),
-			};
+export const getEntityRecords =
+	( kind, name, query = {} ) =>
+	async ( { dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, name } );
+		if ( ! entityConfig || entityConfig?.__experimentalNoFetch ) {
+			return;
 		}
 
-		const path = addQueryArgs( entityConfig.baseURL, {
-			...entityConfig.baseURLParams,
-			...query,
-		} );
+		const lock = await dispatch.__unstableAcquireStoreLock(
+			STORE_NAME,
+			[ 'entities', 'records', kind, name ],
+			{ exclusive: false }
+		);
 
-		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".
-		if ( query._fields ) {
-			records = records.map( ( record ) => {
-				query._fields.split( ',' ).forEach( ( field ) => {
-					if ( ! record.hasOwnProperty( field ) ) {
-						record[ field ] = undefined;
-					}
-				} );
+		try {
+			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: uniq( [
+						...( getNormalizedCommaSeparable( query._fields ) ||
+							[] ),
+						entityConfig.key || DEFAULT_ENTITY_KEY,
+					] ).join(),
+				};
+			}
 
-				return record;
+			const path = addQueryArgs( entityConfig.baseURL, {
+				...entityConfig.baseURLParams,
+				...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
-		if ( ! query?._fields && ! query.context ) {
-			const key = entityConfig.key || DEFAULT_ENTITY_KEY;
-			const resolutionsArgs = records
-				.filter( ( record ) => record[ key ] )
-				.map( ( record ) => [ kind, name, record[ key ] ] );
-
-			dispatch( {
-				type: 'START_RESOLUTIONS',
-				selectorName: 'getEntityRecord',
-				args: resolutionsArgs,
-			} );
-			dispatch( {
-				type: 'FINISH_RESOLUTIONS',
-				selectorName: 'getEntityRecord',
-				args: resolutionsArgs,
-			} );
+			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".
+			if ( query._fields ) {
+				records = records.map( ( record ) => {
+					query._fields.split( ',' ).forEach( ( field ) => {
+						if ( ! record.hasOwnProperty( field ) ) {
+							record[ field ] = undefined;
+						}
+					} );
+
+					return record;
+				} );
+			}
+
+			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
+			if ( ! query?._fields && ! query.context ) {
+				const key = entityConfig.key || DEFAULT_ENTITY_KEY;
+				const resolutionsArgs = records
+					.filter( ( record ) => record[ key ] )
+					.map( ( record ) => [ kind, name, record[ key ] ] );
+
+				dispatch( {
+					type: 'START_RESOLUTIONS',
+					selectorName: 'getEntityRecord',
+					args: resolutionsArgs,
+				} );
+				dispatch( {
+					type: 'FINISH_RESOLUTIONS',
+					selectorName: 'getEntityRecord',
+					args: resolutionsArgs,
+				} );
+			}
+		} finally {
+			dispatch.__unstableReleaseStoreLock( lock );
 		}
-	} finally {
-		dispatch.__unstableReleaseStoreLock( lock );
-	}
-};
+	};
 
 getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 	return (
@@ -218,15 +232,17 @@ getEntityRecords.shouldInvalidate = ( action, kind, name ) => {
 /**
  * Requests the current theme.
  */
-export const getCurrentTheme = () => async ( { dispatch, resolveSelect } ) => {
-	const activeThemes = await resolveSelect.getEntityRecords(
-		'root',
-		'theme',
-		{ status: 'active' }
-	);
+export const getCurrentTheme =
+	() =>
+	async ( { dispatch, resolveSelect } ) => {
+		const activeThemes = await resolveSelect.getEntityRecords(
+			'root',
+			'theme',
+			{ status: 'active' }
+		);
 
-	dispatch.receiveCurrentTheme( activeThemes[ 0 ] );
-};
+		dispatch.receiveCurrentTheme( activeThemes[ 0 ] );
+	};
 
 /**
  * Requests theme supports data from the index.
@@ -238,17 +254,19 @@ export const getThemeSupports = forwardResolver( 'getCurrentTheme' );
  *
  * @param {string} url URL to get the preview for.
  */
-export const getEmbedPreview = ( url ) => async ( { dispatch } ) => {
-	try {
-		const embedProxyResponse = await apiFetch( {
-			path: addQueryArgs( '/oembed/1.0/proxy', { url } ),
-		} );
-		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.
-		dispatch.receiveEmbedPreview( url, false );
-	}
-};
+export const getEmbedPreview =
+	( url ) =>
+	async ( { dispatch } ) => {
+		try {
+			const embedProxyResponse = await apiFetch( {
+				path: addQueryArgs( '/oembed/1.0/proxy', { url } ),
+			} );
+			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.
+			dispatch.receiveEmbedPreview( url, false );
+		}
+	};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -259,42 +277,46 @@ export const getEmbedPreview = ( url ) => async ( { dispatch } ) => {
  * @param {string}  resource REST resource to check, e.g. 'media' or 'posts'.
  * @param {?string} id       ID of the rest resource to check.
  */
-export const canUser = ( action, resource, id ) => async ( { dispatch } ) => {
-	const methods = {
-		create: 'POST',
-		read: 'GET',
-		update: 'PUT',
-		delete: 'DELETE',
-	};
+export const canUser =
+	( action, resource, id ) =>
+	async ( { dispatch } ) => {
+		const methods = {
+			create: 'POST',
+			read: 'GET',
+			update: 'PUT',
+			delete: 'DELETE',
+		};
+
+		const method = methods[ action ];
+		if ( ! method ) {
+			throw new Error( `'${ action }' is not a valid action.` );
+		}
 
-	const method = methods[ action ];
-	if ( ! method ) {
-		throw new Error( `'${ action }' is not a valid action.` );
-	}
+		const path = id
+			? `/wp/v2/${ resource }/${ id }`
+			: `/wp/v2/${ resource }`;
 
-	const path = id ? `/wp/v2/${ resource }/${ id }` : `/wp/v2/${ resource }`;
+		let response;
+		try {
+			response = await apiFetch( {
+				path,
+				method: 'OPTIONS',
+				parse: false,
+			} );
+		} catch ( error ) {
+			// Do nothing if our OPTIONS request comes back with an API error (4xx or
+			// 5xx). The previously determined isAllowed value will remain in the store.
+			return;
+		}
 
-	let response;
-	try {
-		response = await apiFetch( {
-			path,
-			method: 'OPTIONS',
-			parse: false,
-		} );
-	} catch ( error ) {
-		// Do nothing if our OPTIONS request comes back with an API error (4xx or
-		// 5xx). The previously determined isAllowed value will remain in the store.
-		return;
-	}
-
-	// Optional chaining operator is used here because the API requests don't
-	// return the expected result in the native version. Instead, API requests
-	// only return the result, without including response properties like the headers.
-	const allowHeader = response.headers?.get( 'allow' );
-	const key = compact( [ action, resource, id ] ).join( '/' );
-	const isAllowed = includes( allowHeader, method );
-	dispatch.receiveUserPermission( key, isAllowed );
-};
+		// Optional chaining operator is used here because the API requests don't
+		// return the expected result in the native version. Instead, API requests
+		// only return the result, without including response properties like the headers.
+		const allowHeader = response.headers?.get( 'allow' );
+		const key = compact( [ action, resource, id ] ).join( '/' );
+		const isAllowed = includes( allowHeader, method );
+		dispatch.receiveUserPermission( key, isAllowed );
+	};
 
 /**
  * Checks whether the current user can perform the given action on the given
@@ -304,18 +326,18 @@ export const canUser = ( action, resource, id ) => async ( { dispatch } ) => {
  * @param {string} name     Entity name.
  * @param {string} recordId Record's id.
  */
-export const canUserEditEntityRecord = ( kind, name, recordId ) => async ( {
-	dispatch,
-} ) => {
-	const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
-	const entityConfig = find( configs, { kind, name } );
-	if ( ! entityConfig ) {
-		return;
-	}
-
-	const resource = entityConfig.__unstable_rest_base;
-	await dispatch( canUser( 'update', resource, recordId ) );
-};
+export const canUserEditEntityRecord =
+	( kind, name, recordId ) =>
+	async ( { dispatch } ) => {
+		const configs = await dispatch( getOrLoadEntitiesConfig( kind ) );
+		const entityConfig = find( configs, { kind, name } );
+		if ( ! entityConfig ) {
+			return;
+		}
+
+		const resource = entityConfig.__unstable_rest_base;
+		await dispatch( canUser( 'update', resource, recordId ) );
+	};
 
 /**
  * Request autosave data from the REST API.
@@ -323,19 +345,19 @@ export const canUserEditEntityRecord = ( kind, name, recordId ) => async ( {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-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 ) {
-		dispatch.receiveAutosaves( postId, autosaves );
-	}
-};
+export const getAutosaves =
+	( postType, postId ) =>
+	async ( { dispatch, resolveSelect } ) => {
+		const { rest_base: restBase, rest_namespace: restNamespace = 'wp/v2' } =
+			await resolveSelect.getPostType( postType );
+		const autosaves = await apiFetch( {
+			path: `/${ restNamespace }/${ restBase }/${ postId }/autosaves?context=edit`,
+		} );
+
+		if ( autosaves && autosaves.length ) {
+			dispatch.receiveAutosaves( postId, autosaves );
+		}
+	};
 
 /**
  * Request autosave data from the REST API.
@@ -346,50 +368,54 @@ export const getAutosaves = ( postType, postId ) => async ( {
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
  */
-export const getAutosave = ( postType, postId ) => async ( {
-	resolveSelect,
-} ) => {
-	await resolveSelect.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 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 = 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.
-	}
-
-	if ( ! template ) {
-		return;
-	}
-
-	const record = await resolveSelect.getEntityRecord(
-		'postType',
-		'wp_template',
-		template.id
-	);
+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 = 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.
+		}
 
-	if ( record ) {
-		dispatch.receiveEntityRecords( 'postType', 'wp_template', [ record ], {
-			'find-template': link,
-		} );
-	}
-};
+		if ( ! template ) {
+			return;
+		}
+
+		const record = await resolveSelect.getEntityRecord(
+			'postType',
+			'wp_template',
+			template.id
+		);
+
+		if ( record ) {
+			dispatch.receiveEntityRecords(
+				'postType',
+				'wp_template',
+				[ record ],
+				{
+					'find-template': link,
+				}
+			);
+		}
+	};
 
 __experimentalGetTemplateForLink.shouldInvalidate = ( action ) => {
 	return (
@@ -400,82 +426,74 @@ __experimentalGetTemplateForLink.shouldInvalidate = ( action ) => {
 	);
 };
 
-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 __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 }`,
-	} );
-	dispatch.__experimentalReceiveThemeBaseGlobalStyles(
-		currentTheme.stylesheet,
-		themeGlobalStyles
-	);
-};
+export const __experimentalGetCurrentThemeBaseGlobalStyles =
+	() =>
+	async ( { resolveSelect, dispatch } ) => {
+		const currentTheme = await resolveSelect.getCurrentTheme();
+		const themeGlobalStyles = await apiFetch( {
+			path: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }`,
+		} );
+		dispatch.__experimentalReceiveThemeBaseGlobalStyles(
+			currentTheme.stylesheet,
+			themeGlobalStyles
+		);
+	};
 
-export const __experimentalGetCurrentThemeGlobalStylesVariations = () => async ( {
-	resolveSelect,
-	dispatch,
-} ) => {
-	const currentTheme = await resolveSelect.getCurrentTheme();
-	const variations = await apiFetch( {
-		path: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }/variations`,
-	} );
-	dispatch.__experimentalReceiveThemeGlobalStyleVariations(
-		currentTheme.stylesheet,
-		variations
-	);
-};
+export const __experimentalGetCurrentThemeGlobalStylesVariations =
+	() =>
+	async ( { resolveSelect, dispatch } ) => {
+		const currentTheme = await resolveSelect.getCurrentTheme();
+		const variations = await apiFetch( {
+			path: `/wp/v2/global-styles/themes/${ currentTheme.stylesheet }/variations`,
+		} );
+		dispatch.__experimentalReceiveThemeGlobalStyleVariations(
+			currentTheme.stylesheet,
+			variations
+		);
+	};
 
-export const getBlockPatterns = () => async ( { dispatch } ) => {
-	const restPatterns = await apiFetch( {
-		path: '/wp/v2/block-patterns/patterns',
-	} );
-	const patterns = map( restPatterns, ( pattern ) =>
-		mapKeys( pattern, ( value, key ) => {
-			switch ( key ) {
-				case 'block_types':
-					return 'blockTypes';
-				case 'viewport_width':
-					return 'viewportWidth';
-				default:
-					return key;
-			}
-		} )
-	);
-	dispatch( { type: 'RECEIVE_BLOCK_PATTERNS', patterns } );
-};
+export const getBlockPatterns =
+	() =>
+	async ( { dispatch } ) => {
+		const restPatterns = await apiFetch( {
+			path: '/wp/v2/block-patterns/patterns',
+		} );
+		const patterns = map( restPatterns, ( pattern ) =>
+			mapKeys( pattern, ( value, key ) => camelCase( key ) )
+		);
+		dispatch( { type: 'RECEIVE_BLOCK_PATTERNS', patterns } );
+	};
 
-export const getBlockPatternCategories = () => async ( { dispatch } ) => {
-	const categories = await apiFetch( {
-		path: '/wp/v2/block-patterns/categories',
-	} );
-	dispatch( { type: 'RECEIVE_BLOCK_PATTERN_CATEGORIES', categories } );
-};
+export const getBlockPatternCategories =
+	() =>
+	async ( { dispatch } ) => {
+		const categories = await apiFetch( {
+			path: '/wp/v2/block-patterns/categories',
+		} );
+		dispatch( { type: 'RECEIVE_BLOCK_PATTERN_CATEGORIES', categories } );
+	};