@wordpress/core-data 4.0.1 → 4.0.5

package/src/batch/default-processor.js

@@ -1,10 +1,23 @@
+/**
+ * External dependencies
+ */
+import { chunk } from 'lodash';
+
 /**
  * WordPress dependencies
  */
 import apiFetch from '@wordpress/api-fetch';
 
 /**
- * Default batch processor. Sends its input requests to /v1/batch.
+ * Maximum number of requests to place in a single batch request. Obtained by
+ * sending a preflight OPTIONS request to /batch/v1/.
+ *
+ * @type {number?}
+ */
+let maxItems = null;
+
+/**
+ * Default batch processor. Sends its input requests to /batch/v1.
  *
  * @param {Array} requests List of API requests to perform at once.
  *
@@ -13,33 +26,51 @@ import apiFetch from '@wordpress/api-fetch';
  *                   (if not ).
  */
 export default async function defaultProcessor( requests ) {
-	const batchResponse = await apiFetch( {
-		path: '/batch/v1',
-		method: 'POST',
-		data: {
-			validation: 'require-all-validate',
-			requests: requests.map( ( request ) => ( {
-				path: request.path,
-				body: request.data, // Rename 'data' to 'body'.
-				method: request.method,
-				headers: request.headers,
-			} ) ),
-		},
-	} );
-
-	if ( batchResponse.failed ) {
-		return batchResponse.responses.map( ( response ) => ( {
-			error: response?.body,
-		} ) );
+	if ( maxItems === null ) {
+		const preflightResponse = await apiFetch( {
+			path: '/batch/v1',
+			method: 'OPTIONS',
+		} );
+		maxItems = preflightResponse.endpoints[ 0 ].args.requests.maxItems;
 	}
 
-	return batchResponse.responses.map( ( response ) => {
-		const result = {};
-		if ( response.status >= 200 && response.status < 300 ) {
-			result.output = response.body;
+	const results = [];
+
+	for ( const batchRequests of chunk( requests, maxItems ) ) {
+		const batchResponse = await apiFetch( {
+			path: '/batch/v1',
+			method: 'POST',
+			data: {
+				validation: 'require-all-validate',
+				requests: batchRequests.map( ( request ) => ( {
+					path: request.path,
+					body: request.data, // Rename 'data' to 'body'.
+					method: request.method,
+					headers: request.headers,
+				} ) ),
+			},
+		} );
+
+		let batchResults;
+
+		if ( batchResponse.failed ) {
+			batchResults = batchResponse.responses.map( ( response ) => ( {
+				error: response?.body,
+			} ) );
 		} else {
-			result.error = response.body;
+			batchResults = batchResponse.responses.map( ( response ) => {
+				const result = {};
+				if ( response.status >= 200 && response.status < 300 ) {
+					result.output = response.body;
+				} else {
+					result.error = response.body;
+				}
+				return result;
+			} );
 		}
-		return result;
-	} );
+
+		results.push( ...batchResults );
+	}
+
+	return results;
 }

package/src/batch/test/default-processor.js

@@ -11,6 +11,18 @@ import defaultProcessor from '../default-processor';
 jest.mock( '@wordpress/api-fetch' );
 
 describe( 'defaultProcessor', () => {
+	const preflightResponse = {
+		endpoints: [
+			{
+				args: {
+					requests: {
+						maxItems: 25,
+					},
+				},
+			},
+		],
+	};
+
 	const requests = [
 		{
 			path: '/v1/cricketers',
@@ -26,7 +38,12 @@ describe( 'defaultProcessor', () => {
 		},
 	];
 
-	const expectedFetchOptions = {
+	const expectedPreflightOptions = {
+		path: '/batch/v1',
+		method: 'OPTIONS',
+	};
+
+	const expectedBatchOptions = {
 		path: '/batch/v1',
 		method: 'POST',
 		data: {
@@ -49,21 +66,26 @@ describe( 'defaultProcessor', () => {
 	};
 
 	it( 'handles a successful request', async () => {
-		apiFetch.mockImplementation( async () => ( {
-			failed: false,
-			responses: [
-				{
-					status: 200,
-					body: 'Lyon',
-				},
-				{
-					status: 400,
-					body: 'Error!',
-				},
-			],
-		} ) );
+		apiFetch.mockImplementation( async ( { method } ) =>
+			method === 'OPTIONS'
+				? preflightResponse
+				: {
+						failed: false,
+						responses: [
+							{
+								status: 200,
+								body: 'Lyon',
+							},
+							{
+								status: 400,
+								body: 'Error!',
+							},
+						],
+				  }
+		);
 		const results = await defaultProcessor( requests );
-		expect( apiFetch ).toHaveBeenCalledWith( expectedFetchOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedPreflightOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedBatchOptions );
 		expect( results ).toEqual( [
 			{ output: 'Lyon' },
 			{ error: 'Error!' },
@@ -71,18 +93,23 @@ describe( 'defaultProcessor', () => {
 	} );
 
 	it( 'handles a failed request', async () => {
-		apiFetch.mockImplementation( async () => ( {
-			failed: true,
-			responses: [
-				null,
-				{
-					status: 400,
-					body: 'Error!',
-				},
-			],
-		} ) );
+		apiFetch.mockImplementation( async ( { method } ) =>
+			method === 'OPTIONS'
+				? preflightResponse
+				: {
+						failed: true,
+						responses: [
+							null,
+							{
+								status: 400,
+								body: 'Error!',
+							},
+						],
+				  }
+		);
 		const results = await defaultProcessor( requests );
-		expect( apiFetch ).toHaveBeenCalledWith( expectedFetchOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedPreflightOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedBatchOptions );
 		expect( results ).toEqual( [
 			{ error: undefined },
 			{ error: 'Error!' },

package/src/entities.js

@@ -6,24 +6,24 @@ import { upperFirst, camelCase, map, find, get, startCase } from 'lodash';
 /**
  * WordPress dependencies
  */
-import { controls } from '@wordpress/data';
-import { apiFetch } from '@wordpress/data-controls';
+import apiFetch from '@wordpress/api-fetch';
 import { __ } from '@wordpress/i18n';
 
 /**
  * Internal dependencies
  */
 import { addEntities } from './actions';
-import { STORE_NAME } from './name';
 
 export const DEFAULT_ENTITY_KEY = 'id';
 
+const POST_RAW_ATTRIBUTES = [ 'title', 'excerpt', 'content' ];
+
 export const defaultEntities = [
 	{
 		label: __( 'Base' ),
 		name: '__unstableBase',
 		kind: 'root',
-		baseURL: '',
+		baseURL: '/',
 	},
 	{
 		label: __( 'Site' ),
@@ -41,6 +41,7 @@ export const defaultEntities = [
 		key: 'slug',
 		baseURL: '/wp/v2/types',
 		baseURLParams: { context: 'edit' },
+		rawAttributes: POST_RAW_ATTRIBUTES,
 	},
 	{
 		name: 'media',
@@ -115,6 +116,7 @@ export const defaultEntities = [
 		baseURLParams: { context: 'edit' },
 		plural: 'menuItems',
 		label: __( 'Menu Item' ),
+		rawAttributes: [ 'title', 'content' ],
 	},
 	{
 		name: 'menuLocation',
@@ -125,6 +127,33 @@ export const defaultEntities = [
 		label: __( 'Menu Location' ),
 		key: 'name',
 	},
+	{
+		name: 'navigationArea',
+		kind: 'root',
+		baseURL: '/__experimental/block-navigation-areas',
+		baseURLParams: { context: 'edit' },
+		plural: 'navigationAreas',
+		label: __( 'Navigation Area' ),
+		key: 'name',
+		getTitle: ( record ) => record?.description,
+	},
+	{
+		label: __( 'Global Styles' ),
+		name: 'globalStyles',
+		kind: 'root',
+		baseURL: '/wp/v2/global-styles',
+		baseURLParams: { context: 'edit' },
+		plural: 'globalStylesVariations', // should be different than name
+		getTitle: ( record ) => record?.title?.rendered || record?.title,
+	},
+	{
+		label: __( 'Themes' ),
+		name: 'theme',
+		kind: 'root',
+		baseURL: '/wp/v2/themes',
+		baseURLParams: { context: 'edit' },
+		key: 'stylesheet',
+	},
 ];
 
 export const kinds = [
@@ -167,15 +196,16 @@ export const prePersistPostType = ( persistedRecord, edits ) => {
  *
  * @return {Promise} Entities promise
  */
-function* loadPostTypeEntities() {
-	const postTypes = yield apiFetch( { path: '/wp/v2/types?context=edit' } );
+async function loadPostTypeEntities() {
+	const postTypes = await apiFetch( { path: '/wp/v2/types?context=edit' } );
 	return map( postTypes, ( postType, name ) => {
 		const isTemplate = [ 'wp_template', 'wp_template_part' ].includes(
 			name
 		);
+		const namespace = postType?.rest_namespace ?? 'wp/v2';
 		return {
 			kind: 'postType',
-			baseURL: '/wp/v2/' + postType.rest_base,
+			baseURL: `/${ namespace }/${ postType.rest_base }`,
 			baseURLParams: { context: 'edit' },
 			name,
 			label: postType.labels.singular_name,
@@ -184,6 +214,7 @@ function* loadPostTypeEntities() {
 				selection: true,
 			},
 			mergedEdits: { meta: true },
+			rawAttributes: POST_RAW_ATTRIBUTES,
 			getTitle: ( record ) =>
 				record?.title?.rendered ||
 				record?.title ||
@@ -199,14 +230,15 @@ function* loadPostTypeEntities() {
  *
  * @return {Promise} Entities promise
  */
-function* loadTaxonomyEntities() {
-	const taxonomies = yield apiFetch( {
+async function loadTaxonomyEntities() {
+	const taxonomies = await apiFetch( {
 		path: '/wp/v2/taxonomies?context=edit',
 	} );
 	return map( taxonomies, ( taxonomy, name ) => {
+		const namespace = taxonomy?.rest_namespace ?? 'wp/v2';
 		return {
 			kind: 'taxonomy',
-			baseURL: '/wp/v2/' + taxonomy.rest_base,
+			baseURL: `/${ namespace }/${ taxonomy.rest_base }`,
 			baseURLParams: { context: 'edit' },
 			name,
 			label: taxonomy.labels.singular_name,
@@ -248,12 +280,8 @@ export const getMethodName = (
  *
  * @return {Array} Entities
  */
-export function* getKindEntities( kind ) {
-	let entities = yield controls.select(
-		STORE_NAME,
-		'getEntitiesByKind',
-		kind
-	);
+export const getKindEntities = ( kind ) => async ( { select, dispatch } ) => {
+	let entities = select.getEntitiesByKind( kind );
 	if ( entities && entities.length !== 0 ) {
 		return entities;
 	}
@@ -263,8 +291,8 @@ export function* getKindEntities( kind ) {
 		return [];
 	}
 
-	entities = yield kindConfig.loadEntities();
-	yield addEntities( entities );
+	entities = await kindConfig.loadEntities();
+	dispatch( addEntities( entities ) );
 
 	return entities;
-}
+};

package/src/fetch/__experimental-fetch-url-data.js

@@ -45,7 +45,7 @@ const CACHE = new Map();
  * @return {Promise< WPRemoteUrlData[] >} Remote URL data.
  */
 const fetchUrlData = async ( url, options = {} ) => {
-	const endpoint = '/__experimental/url-details';
+	const endpoint = '/wp-block-editor/v1/url-details';
 
 	const args = {
 		url: prependHTTP( url ),

package/src/index.js

@@ -2,7 +2,6 @@
  * WordPress dependencies
  */
 import { createReduxStore, register } from '@wordpress/data';
-import { controls } from '@wordpress/data-controls';
 
 /**
  * Internal dependencies
@@ -11,9 +10,7 @@ import reducer from './reducer';
 import * as selectors from './selectors';
 import * as actions from './actions';
 import * as resolvers from './resolvers';
-import * as locksSelectors from './locks/selectors';
-import * as locksActions from './locks/actions';
-import customControls from './controls';
+import createLocksActions from './locks/actions';
 import { defaultEntities, getMethodName } from './entities';
 import { STORE_NAME } from './name';
 
@@ -57,13 +54,13 @@ const entityActions = defaultEntities.reduce( ( result, entity ) => {
 	return result;
 }, {} );
 
-const storeConfig = {
+const storeConfig = () => ( {
 	reducer,
-	controls: { ...customControls, ...controls },
-	actions: { ...actions, ...entityActions, ...locksActions },
-	selectors: { ...selectors, ...entitySelectors, ...locksSelectors },
+	actions: { ...actions, ...entityActions, ...createLocksActions() },
+	selectors: { ...selectors, ...entitySelectors },
 	resolvers: { ...resolvers, ...entityResolvers },
-};
+	__experimentalUseThunks: true,
+} );
 
 /**
  * Store definition for the code data namespace.
@@ -72,7 +69,7 @@ const storeConfig = {
  *
  * @type {Object}
  */
-export const store = createReduxStore( STORE_NAME, storeConfig );
+export const store = createReduxStore( STORE_NAME, storeConfig() );
 
 register( store );
 

package/src/locks/actions.js

@@ -1,69 +1,18 @@
-/**
- * WordPress dependencies
- */
-import { __unstableAwaitPromise } from '@wordpress/data-controls';
-import { controls } from '@wordpress/data';
-
 /**
  * Internal dependencies
  */
-import { STORE_NAME } from '../name';
+import createLocks from './engine';
 
-export function* __unstableAcquireStoreLock( store, path, { exclusive } ) {
-	const promise = yield* __unstableEnqueueLockRequest( store, path, {
-		exclusive,
-	} );
-	yield* __unstableProcessPendingLockRequests();
-	return yield __unstableAwaitPromise( promise );
-}
+export default function createLocksActions() {
+	const locks = createLocks();
 
-export function* __unstableEnqueueLockRequest( store, path, { exclusive } ) {
-	let notifyAcquired;
-	const promise = new Promise( ( resolve ) => {
-		notifyAcquired = resolve;
-	} );
-	yield {
-		type: 'ENQUEUE_LOCK_REQUEST',
-		request: { store, path, exclusive, notifyAcquired },
-	};
-	return promise;
-}
-
-export function* __unstableReleaseStoreLock( lock ) {
-	yield {
-		type: 'RELEASE_LOCK',
-		lock,
-	};
-	yield* __unstableProcessPendingLockRequests();
-}
+	function __unstableAcquireStoreLock( store, path, { exclusive } ) {
+		return () => locks.acquire( store, path, exclusive );
+	}
 
-export function* __unstableProcessPendingLockRequests() {
-	yield {
-		type: 'PROCESS_PENDING_LOCK_REQUESTS',
-	};
-	const lockRequests = yield controls.select(
-		STORE_NAME,
-		'__unstableGetPendingLockRequests'
-	);
-	for ( const request of lockRequests ) {
-		const { store, path, exclusive, notifyAcquired } = request;
-		const isAvailable = yield controls.select(
-			STORE_NAME,
-			'__unstableIsLockAvailable',
-			store,
-			path,
-			{
-				exclusive,
-			}
-		);
-		if ( isAvailable ) {
-			const lock = { store, path, exclusive };
-			yield {
-				type: 'GRANT_LOCK_REQUEST',
-				lock,
-				request,
-			};
-			notifyAcquired( lock );
-		}
+	function __unstableReleaseStoreLock( lock ) {
+		return () => locks.release( lock );
 	}
+
+	return { __unstableAcquireStoreLock, __unstableReleaseStoreLock };
 }

package/src/locks/engine.js

@@ -0,0 +1,43 @@
+/**
+ * Internal dependencies
+ */
+import reducer from './reducer';
+import { isLockAvailable, getPendingLockRequests } from './selectors';
+
+export default function createLocks() {
+	let state = reducer( undefined, { type: '@@INIT' } );
+
+	function processPendingLockRequests() {
+		for ( const request of getPendingLockRequests( state ) ) {
+			const { store, path, exclusive, notifyAcquired } = request;
+			if ( isLockAvailable( state, store, path, { exclusive } ) ) {
+				const lock = { store, path, exclusive };
+				state = reducer( state, {
+					type: 'GRANT_LOCK_REQUEST',
+					lock,
+					request,
+				} );
+				notifyAcquired( lock );
+			}
+		}
+	}
+
+	function acquire( store, path, exclusive ) {
+		return new Promise( ( resolve ) => {
+			state = reducer( state, {
+				type: 'ENQUEUE_LOCK_REQUEST',
+				request: { store, path, exclusive, notifyAcquired: resolve },
+			} );
+			processPendingLockRequests();
+		} );
+	}
+	function release( lock ) {
+		state = reducer( state, {
+			type: 'RELEASE_LOCK',
+			lock,
+		} );
+		processPendingLockRequests();
+	}
+
+	return { acquire, release };
+}

package/src/locks/reducer.js

@@ -19,7 +19,7 @@ const DEFAULT_STATE = {
  *
  * @return {Object} Updated state.
  */
-export function locks( state = DEFAULT_STATE, action ) {
+export default function locks( state = DEFAULT_STATE, action ) {
 	switch ( action.type ) {
 		case 'ENQUEUE_LOCK_REQUEST': {
 			const { request } = action;
@@ -60,5 +60,3 @@ export function locks( state = DEFAULT_STATE, action ) {
 
 	return state;
 }
-
-export default locks;

package/src/locks/selectors.js

@@ -8,13 +8,13 @@ import {
 	getNode,
 } from './utils';
 
-export function __unstableGetPendingLockRequests( state ) {
-	return state.locks.requests;
+export function getPendingLockRequests( state ) {
+	return state.requests;
 }
 
-export function __unstableIsLockAvailable( state, store, path, { exclusive } ) {
+export function isLockAvailable( state, store, path, { exclusive } ) {
 	const storePath = [ store, ...path ];
-	const locks = state.locks.tree;
+	const locks = state.tree;
 
 	// Validate all parents and the node itself
 	for ( const node of iteratePath( locks, storePath ) ) {