@wordpress/core-data 7.48.1 → 7.49.0

package/src/resolvers.js

@@ -1355,14 +1355,24 @@ export const getEditorAssets =
 /**
  * Requests view config for a given entity type from the REST API.
  *
- * @param {string} kind Entity kind.
- * @param {string} name Entity name.
+ * @param {string}    kind           Entity kind.
+ * @param {string}    name           Entity name.
+ * @param {?Object}   options        Optional options.
+ * @param {?string[]} options.fields Optional subset of top-level config
+ *                                   properties to request, mapped to the REST
+ *                                   API `_fields` parameter. When omitted, the
+ *                                   full config is requested.
  */
 export const getViewConfig =
-	( kind, name ) =>
+	( kind, name, options = {} ) =>
 	async ( { dispatch } ) => {
+		const query = { kind, name };
+		const fields = getNormalizedCommaSeparable( options.fields );
+		if ( fields?.length ) {
+			query._fields = fields.join( ',' );
+		}
 		const config = await apiFetch( {
-			path: addQueryArgs( '/wp/v2/view-config', { kind, name } ),
+			path: addQueryArgs( '/wp/v2/view-config', query ),
 		} );
 		dispatch.receiveViewConfig( kind, name, config );
 	};

package/src/test/entities.js

@@ -136,15 +136,20 @@ describe( 'prePersistPostType', () => {
 
 describe( 'loadPostTypeEntities', () => {
 	let originalCollaborationEnabled;
+	let originalCollaborationDisabledPostTypes;
 
 	beforeEach( () => {
 		apiFetch.mockReset();
 		applyPostChangesToCRDTDoc.mockReset();
 		originalCollaborationEnabled = window._wpCollaborationEnabled;
+		originalCollaborationDisabledPostTypes =
+			window._wpCollaborationDisabledPostTypes;
 	} );
 
 	afterEach( () => {
 		window._wpCollaborationEnabled = originalCollaborationEnabled;
+		window._wpCollaborationDisabledPostTypes =
+			originalCollaborationDisabledPostTypes;
 	} );
 
 	it( 'should include custom taxonomy rest_bases in synced properties when collaboration is enabled', async () => {
@@ -224,6 +229,52 @@ describe( 'loadPostTypeEntities', () => {
 		expect( syncedProperties ).not.toContain( 'tags' );
 	} );
 
+	it( 'should sync post type entities by default', async () => {
+		window._wpCollaborationEnabled = false;
+		window._wpCollaborationDisabledPostTypes = undefined;
+
+		const mockPostTypes = {
+			post: {
+				name: 'Posts',
+				rest_base: 'posts',
+				rest_namespace: 'wp/v2',
+			},
+		};
+
+		apiFetch.mockResolvedValueOnce( mockPostTypes );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const postEntity = entities.find( ( e ) => e.name === 'post' );
+
+		expect( postEntity.syncConfig.shouldSync() ).toBe( true );
+	} );
+
+	it( 'should not sync post type entities disabled for collaboration', async () => {
+		window._wpCollaborationEnabled = false;
+		window._wpCollaborationDisabledPostTypes = [ 'book' ];
+
+		const mockPostTypes = {
+			book: {
+				name: 'Books',
+				rest_base: 'books',
+				rest_namespace: 'wp/v2',
+			},
+		};
+
+		apiFetch.mockResolvedValueOnce( mockPostTypes );
+
+		const postTypeLoader = additionalEntityConfigLoaders.find(
+			( loader ) => loader.kind === 'postType'
+		);
+		const entities = await postTypeLoader.loadEntities();
+		const bookEntity = entities.find( ( e ) => e.name === 'book' );
+
+		expect( bookEntity.syncConfig.shouldSync() ).toBe( false );
+	} );
+
 	it( 'should skip taxonomy rest_base when taxonomy is not found in fetched taxonomies', async () => {
 		window._wpCollaborationEnabled = true;
 

package/src/utils/clear-unchanged-edits.ts

@@ -0,0 +1,34 @@
+/**
+ * External dependencies
+ */
+import fastDeepEqual from 'fast-deep-equal/es6/index.js';
+
+/**
+ * Returns a copy of `edits` where any value equal to its persisted counterpart
+ * is set to `undefined`. The edits reducer treats `undefined` as a signal to
+ * drop the edit, so the property is no longer considered dirty.
+ *
+ * @param edits           Edits keyed by property name.
+ * @param persistedRecord Persisted entity record to compare against.
+ *
+ * @return Edits with unchanged properties set to `undefined`.
+ */
+export default function clearUnchangedEdits(
+	edits: Record< string, unknown >,
+	persistedRecord: Record< string, any > | undefined
+): Record< string, unknown > {
+	if ( ! persistedRecord ) {
+		return edits;
+	}
+
+	return Object.fromEntries(
+		Object.entries( edits ).map( ( [ key, value ] ) => {
+			const persisted =
+				persistedRecord[ key ]?.raw ?? persistedRecord[ key ];
+			return [
+				key,
+				fastDeepEqual( value, persisted ) ? undefined : value,
+			];
+		} )
+	);
+}

package/src/utils/index.js

@@ -1,3 +1,4 @@
+export { default as clearUnchangedEdits } from './clear-unchanged-edits';
 export { default as conservativeMapItem } from './conservative-map-item';
 export { default as getNormalizedCommaSeparable } from './get-normalized-comma-separable';
 export { default as ifMatchingAction } from './if-matching-action';

package/src/utils/test/clear-unchanged-edits.js

@@ -0,0 +1,42 @@
+/**
+ * Internal dependencies
+ */
+import clearUnchangedEdits from '../clear-unchanged-edits';
+
+describe( 'clearUnchangedEdits', () => {
+	it( 'sets edits matching the persisted record to undefined', () => {
+		const result = clearUnchangedEdits(
+			{ title: 'Hello', status: 'draft' },
+			{ title: 'Hello', status: 'publish' }
+		);
+
+		expect( result ).toEqual( { title: undefined, status: 'draft' } );
+	} );
+
+	it( 'unwraps the persisted value from its `raw` subfield', () => {
+		const result = clearUnchangedEdits(
+			{ title: 'Hello', content: 'World' },
+			{
+				title: { raw: 'Hello', rendered: '<p>Hello</p>' },
+				content: { raw: 'Changed', rendered: '<p>Changed</p>' },
+			}
+		);
+
+		expect( result ).toEqual( { title: undefined, content: 'World' } );
+	} );
+
+	it( 'compares deeply for object values', () => {
+		const result = clearUnchangedEdits(
+			{ meta: { a: 1 }, other: { b: 1 } },
+			{ meta: { a: 1 }, other: { b: 2 } }
+		);
+
+		expect( result ).toEqual( { meta: undefined, other: { b: 1 } } );
+	} );
+
+	it( 'keeps all edits when there is no persisted record', () => {
+		const result = clearUnchangedEdits( { title: 'Hello' }, undefined );
+
+		expect( result ).toEqual( { title: 'Hello' } );
+	} );
+} );

package/build-types/utils/on-sub-key.d.ts

@@ -1,4 +0,0 @@
-export function onSubKey(actionProperty: string): AnyFunction;
-export default onSubKey;
-export type AnyFunction = import("../types").AnyFunction;
-//# sourceMappingURL=on-sub-key.d.ts.map

package/build-types/utils/on-sub-key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"on-sub-key.d.ts","sourceRoot":"","sources":["../../src/utils/on-sub-key.js"],"names":[],"mappings":"AAUO,yCAJI,MAAM,GAEL,WAAW,CAwBrB;;0BAhCY,OAAO,UAAU,EAAE,WAAW"}