@wordpress/core-data 7.48.1 → 7.48.2-next.v.202606191442.0

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

@@ -7,7 +7,7 @@ import { useSelect } from '@wordpress/data';
  * Internal dependencies
  */
 import memoize from 'memize';
-import { Status } from './constants';
+import { getResolutionStatus } from './utils';
 
 export const META_SELECTORS = [
 	'getIsResolving',
@@ -114,30 +114,9 @@ const enrichSelectors = memoize( ( ( selectors ) => {
 						args
 					)?.status;
 
-					let status;
-					switch ( resolutionStatus ) {
-						case 'resolving':
-							status = Status.Resolving;
-							break;
-						case 'finished':
-							status = Status.Success;
-							break;
-						case 'error':
-							status = Status.Error;
-							break;
-						case undefined:
-							status = Status.Idle;
-							break;
-					}
-
 					return {
 						data,
-						status,
-						isResolving: status === Status.Resolving,
-						hasStarted: status !== Status.Idle,
-						hasResolved:
-							status === Status.Success ||
-							status === Status.Error,
+						...getResolutionStatus( resolutionStatus ),
 					};
 				},
 		} );

package/src/hooks/utils.ts

@@ -0,0 +1,40 @@
+/**
+ * WordPress dependencies
+ */
+import type { ResolutionStatus } from '@wordpress/data';
+
+/**
+ * Internal dependencies
+ */
+import { Status } from './constants';
+
+/**
+ * Normalizes a resolution status from the store into the resolution info
+ * shared by the entity record hooks and `useQuerySelect`.
+ *
+ * @param resolutionStatus Status returned by the `getResolutionState` selector.
+ * @return Resolution info object.
+ */
+export function getResolutionStatus( resolutionStatus?: ResolutionStatus ) {
+	let status: Status;
+	switch ( resolutionStatus ) {
+		case 'resolving':
+			status = Status.Resolving;
+			break;
+		case 'finished':
+			status = Status.Success;
+			break;
+		case 'error':
+			status = Status.Error;
+			break;
+		default:
+			status = Status.Idle;
+	}
+
+	return {
+		status,
+		isResolving: status === Status.Resolving,
+		hasStarted: status !== Status.Idle,
+		hasResolved: status === Status.Success || status === Status.Error,
+	};
+}

package/src/reducer.js

@@ -13,7 +13,7 @@ import { createUndoManager } from '@wordpress/undo-manager';
 /**
  * Internal dependencies
  */
-import { ifMatchingAction, replaceAction } from './utils';
+import { clearUnchangedEdits, ifMatchingAction, replaceAction } from './utils';
 import { reducer as queriedDataReducer } from './queried-data';
 import { rootEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 import { ConnectionErrorCode } from './sync';
@@ -150,19 +150,23 @@ const withMultiEntityRecordEdits = ( reducer ) => ( state, action ) => {
 
 		let newState = state;
 		record.forEach( ( { id: { kind, name, recordId }, changes } ) => {
+			const persistedRecord =
+				state?.queriedData?.items?.default?.[ recordId ];
+			const edits = Object.fromEntries(
+				Object.entries( changes ).map( ( [ key, value ] ) => [
+					key,
+					action.type === 'UNDO' ? value.from : value.to,
+				] )
+			);
+
 			newState = reducer( newState, {
 				type: 'EDIT_ENTITY_RECORD',
 				kind,
 				name,
 				recordId,
-				edits: Object.entries( changes ).reduce(
-					( acc, [ key, value ] ) => {
-						acc[ key ] =
-							action.type === 'UNDO' ? value.from : value.to;
-						return acc;
-					},
-					{}
-				),
+				// Clear edits matching the persisted record so the entity is
+				// no longer dirty after undoing back to its saved state.
+				edits: clearUnchangedEdits( edits, persistedRecord ),
 			} );
 		} );
 		return newState;

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"}