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

package/src/hooks/use-entity-record.ts

@@ -8,9 +8,9 @@ import { useMemo } from '@wordpress/element';
 /**
  * Internal dependencies
  */
-import useQuerySelect from './use-query-select';
 import { store as coreStore } from '../';
 import type { Status } from './constants';
+import { getResolutionStatus } from './utils';
 
 export interface EntityRecordResolution< RecordType > {
 	/** The requested entity record */
@@ -38,6 +38,11 @@ export interface EntityRecordResolution< RecordType > {
 	 */
 	hasEdits: boolean;
 
+	/**
+	 * Has the resolution started?
+	 */
+	hasStarted: boolean;
+
 	/**
 	 * Is the record resolved by now?
 	 */
@@ -169,57 +174,59 @@ export default function useEntityRecord< RecordType >(
 		[ editEntityRecord, kind, name, recordId, saveEditedEntityRecord ]
 	);
 
-	const { editedRecord, hasEdits, edits } = useSelect(
+	const { record, editedRecord, hasEdits, edits, ...resolution } = useSelect(
 		( select ) => {
 			if ( ! options.enabled ) {
 				return {
+					record: null,
 					editedRecord: EMPTY_OBJECT,
 					hasEdits: false,
 					edits: EMPTY_OBJECT,
+					...getResolutionStatus(),
 				};
 			}
 
+			const storeSelectors = select( coreStore );
+			const resolutionStatus = storeSelectors.getResolutionState(
+				'getEntityRecord',
+				[ kind, name, recordId ]
+			)?.status;
+
 			return {
-				editedRecord: select( coreStore ).getEditedEntityRecord(
+				record: ( storeSelectors.getEntityRecord(
+					kind,
+					name,
+					recordId
+				) ?? null ) as RecordType | null,
+				editedRecord: storeSelectors.getEditedEntityRecord(
 					kind,
 					name,
 					recordId
 				),
-				hasEdits: select( coreStore ).hasEditsForEntityRecord(
+				hasEdits: storeSelectors.hasEditsForEntityRecord(
 					kind,
 					name,
 					recordId
 				),
-				edits: select( coreStore ).getEntityRecordNonTransientEdits(
+				edits: storeSelectors.getEntityRecordNonTransientEdits(
 					kind,
 					name,
 					recordId
 				),
+				...getResolutionStatus( resolutionStatus ),
 			};
 		},
 		[ kind, name, recordId, options.enabled ]
 	);
 
-	const { data: record, ...querySelectRest } = useQuerySelect(
-		( query ) => {
-			if ( ! options.enabled ) {
-				return {
-					data: null,
-				};
-			}
-			return query( coreStore ).getEntityRecord( kind, name, recordId );
-		},
-		[ kind, name, recordId, options.enabled ]
-	);
-
 	return {
 		record,
 		editedRecord,
 		hasEdits,
 		edits,
-		...querySelectRest,
+		...resolution,
 		...mutations,
-	};
+	} as EntityRecordResolution< RecordType >;
 }
 
 export function useDeprecatedEntityRecord(

package/src/hooks/use-entity-records.ts

@@ -9,14 +9,14 @@ import { useMemo } from '@wordpress/element';
 /**
  * Internal dependencies
  */
-import useQuerySelect from './use-query-select';
 import { store as coreStore } from '../';
 import type { Options } from './use-entity-record';
 import type { Status } from './constants';
+import { getResolutionStatus } from './utils';
 import { unlock } from '../lock-unlock';
 import { getNormalizedCommaSeparable } from '../utils';
 
-interface EntityRecordsResolution< RecordType > {
+export interface EntityRecordsResolution< RecordType > {
 	/** The requested entity records */
 	records: RecordType[] | null;
 
@@ -25,6 +25,11 @@ interface EntityRecordsResolution< RecordType > {
 	 */
 	isResolving: boolean;
 
+	/**
+	 * Has the resolution started?
+	 */
+	hasStarted: boolean;
+
 	/**
 	 * Is the record resolved by now?
 	 */
@@ -108,38 +113,41 @@ export default function useEntityRecords< RecordType >(
 	// if the values remain the same.
 	const queryAsString = addQueryArgs( '', queryArgs );
 
-	const { data: records, ...rest } = useQuerySelect(
-		( query ) => {
-			if ( ! options.enabled ) {
-				return {
-					// Avoiding returning a new reference on every execution.
-					data: EMPTY_ARRAY,
-				};
-			}
-			return query( coreStore ).getEntityRecords( kind, name, queryArgs );
-		},
-		[ kind, name, queryAsString, options.enabled ]
-	);
-
-	const { totalItems, totalPages } = useSelect(
+	const { records, totalItems, totalPages, ...rest } = useSelect(
 		( select ) => {
 			if ( ! options.enabled ) {
 				return {
+					// Avoiding returning a new reference on every execution.
+					records: EMPTY_ARRAY,
 					totalItems: null,
 					totalPages: null,
+					...getResolutionStatus(),
 				};
 			}
+
+			const storeSelectors = select( coreStore );
+			const resolutionStatus = storeSelectors.getResolutionState(
+				'getEntityRecords',
+				[ kind, name, queryArgs ]
+			)?.status;
+
 			return {
-				totalItems: select( coreStore ).getEntityRecordsTotalItems(
+				records: storeSelectors.getEntityRecords(
+					kind,
+					name,
+					queryArgs
+				) as RecordType[] | null,
+				totalItems: storeSelectors.getEntityRecordsTotalItems(
 					kind,
 					name,
 					queryArgs
 				),
-				totalPages: select( coreStore ).getEntityRecordsTotalPages(
+				totalPages: storeSelectors.getEntityRecordsTotalPages(
 					kind,
 					name,
 					queryArgs
 				),
+				...getResolutionStatus( resolutionStatus ),
 			};
 		},
 		[ kind, name, queryAsString, options.enabled ]

package/src/hooks/use-post-editor-awareness-state.ts

@@ -2,13 +2,15 @@
  * External dependencies
  */
 import { usePrevious } from '@wordpress/compose';
-import { useEffect, useState } from '@wordpress/element';
+import { useEffect, useState, useCallback } from '@wordpress/element';
 import type { Y } from '@wordpress/sync';
 
 /**
  * Internal dependencies
  */
 import { getSyncManager } from '../sync';
+import { usePostContentBlocks } from '../awareness/block-lookup';
+import type { EditorStoreBlock } from '../awareness/block-lookup';
 import type {
 	PostEditorAwarenessState as ActiveCollaborator,
 	PostSaveEvent,
@@ -19,7 +21,10 @@ import type { PostEditorAwareness } from '../awareness/post-editor-awareness';
 
 interface AwarenessState {
 	activeCollaborators: ActiveCollaborator[];
-	resolveSelection: ( selection: SelectionState ) => ResolvedSelection;
+	resolveSelection: (
+		selection: SelectionState,
+		blocks: EditorStoreBlock[]
+	) => ResolvedSelection;
 	getDebugData: () => YDocDebugData;
 	isCurrentCollaboratorDisconnected: boolean;
 }
@@ -49,8 +54,10 @@ function getAwarenessState(
 
 	return {
 		activeCollaborators,
-		resolveSelection: ( selection: SelectionState ) =>
-			awareness.convertSelectionStateToAbsolute( selection ),
+		resolveSelection: (
+			selection: SelectionState,
+			blocks: EditorStoreBlock[]
+		) => awareness.convertSelectionStateToAbsolute( selection, blocks ),
 		getDebugData: () => awareness.getDebugData(),
 		isCurrentCollaboratorDisconnected:
 			activeCollaborators.find( ( collaborator ) => collaborator.isMe )
@@ -124,7 +131,13 @@ export function useResolvedSelection(
 	postId: number | null,
 	postType: string | null
 ): ( selection: SelectionState ) => ResolvedSelection {
-	return usePostEditorAwarenessState( postId, postType ).resolveSelection;
+	const blocks = usePostContentBlocks();
+	const awarenessState = usePostEditorAwarenessState( postId, postType );
+	return useCallback(
+		( selection: SelectionState ) =>
+			awarenessState.resolveSelection( selection, blocks ),
+		[ blocks, awarenessState ]
+	);
 }
 
 /**
@@ -158,8 +171,8 @@ export function useIsDisconnected(
 
 /**
  * Hook that subscribes to the CRDT state map and returns the most recent
- * save event (timestamp + client ID). The state map is updated by
- * `markEntityAsSaved` in `@wordpress/sync`
+ * user-facing post save event (timestamp + client ID). The state map is
+ * updated by `markEntityAsSaved` in `@wordpress/sync`.
  *
  * @param postId   The ID of the post.
  * @param postType The type of the post.

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/private-actions.js

@@ -197,6 +197,24 @@ export function receiveViewConfig( kind, name, config ) {
 	};
 }
 
+/**
+ * Returns an action object used to notify core-data that the sync undo manager
+ * state changed outside of the core-data reducer, e.g. The Yjs UndoManager
+ * captured an undo level.
+ *
+ * @param {Object}  state         The sync undo stack state.
+ * @param {boolean} state.hasRedo Whether there are changes to redo.
+ * @param {boolean} state.hasUndo Whether there are changes to undo.
+ *
+ * @return {Object} Action object.
+ */
+export function __unstableNotifySyncUndoManagerChange( state ) {
+	return {
+		type: 'SYNC_UNDO_MANAGER_CHANGE',
+		...state,
+	};
+}
+
 /**
  * Returns an action object used to set the sync connection status for an entity or collection.
  *

package/src/private-selectors.ts

@@ -21,18 +21,6 @@ const EMPTY_OBJECT = {};
  * Returns the previous edit from the current undo offset
  * for the entity records edits history, if any.
  *
- * Known Issue: Every-time state.undoManager changes, the getUndoManager
- * private selector is called (if used within useSelect and things like that)
- * which ensures the UI is always properly reactive. But, it's not the case with
- * the custom "sync" undo manager.
- *
- * Assumption: When an undo/redo is created, other parts of the core-data state
- * are likely changing simultaneously, which will trigger the selectors again.
- *
- * This issue is acceptable based on the assumption above.
- *
- * @see https://github.com/WordPress/gutenberg/pull/72407/files#r2580214235 for more details.
- *
  * @param state State tree.
  *
  * @return The undo manager.

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;
@@ -460,6 +464,22 @@ export function undoManager( state = createUndoManager() ) {
 	return state;
 }
 
+// Stores a snapshot of the sync undo manager's undo/redo availability so
+// core-data selectors can react to undo stack changes.
+export function syncUndoManagerState(
+	state = { hasRedo: false, hasUndo: false },
+	action
+) {
+	switch ( action.type ) {
+		case 'SYNC_UNDO_MANAGER_CHANGE':
+			return {
+				hasRedo: action.hasRedo,
+				hasUndo: action.hasUndo,
+			};
+	}
+	return state;
+}
+
 export function editsReference( state = {}, action ) {
 	switch ( action.type ) {
 		case 'EDIT_ENTITY_RECORD':
@@ -750,6 +770,7 @@ export default combineReducers( {
 	themeGlobalStyleRevisions,
 	entities,
 	editsReference,
+	syncUndoManagerState,
 	undoManager,
 	embedPreviews,
 	userPermissions,

package/src/resolvers.js

@@ -25,6 +25,7 @@ import {
 	RECEIVE_INTERMEDIATE_RESULTS,
 	isNumericID,
 	normalizeQueryForResolution,
+	saveCRDTDoc,
 } from './utils';
 import { fetchBlockPatterns } from './fetch';
 import { restoreSelection, getSelectionHistory } from './utils/crdt-selection';
@@ -250,9 +251,15 @@ export const getEntityRecord =
 						// persistence. As we add support for syncing additional entity,
 						// we'll need to revisit where persisted CRDT documents are stored.
 						persistCRDTDoc: () => {
-							resolveSelect
+							if (
+								! entityConfig.syncConfig?.supportsPersistence
+							) {
+								return;
+							}
+
+							return resolveSelect
 								.getEditedEntityRecord( kind, name, key )
-								.then( ( editedRecord ) => {
+								.then( async ( editedRecord ) => {
 									// Don't persist the CRDT document if the record is still an
 									// auto-draft or if the entity does not support meta.
 									const { meta, status } = editedRecord;
@@ -260,19 +267,14 @@ export const getEntityRecord =
 										return;
 									}
 
-									// Trigger a minimal save to persist the CRDT document. The
-									// entity's pre-persist hooks will create the persisted CRDT
-									// document and apply it to the record's meta.
 									const entityIdKey =
 										entityConfig.key || DEFAULT_ENTITY_KEY;
-									dispatch.saveEntityRecord(
-										kind,
-										name,
-										{
-											[ entityIdKey ]:
-												editedRecord[ entityIdKey ],
-										},
-										{ __unstableSkipSyncUpdate: true }
+									const entityId =
+										editedRecord[ entityIdKey ];
+
+									await saveCRDTDoc(
+										`${ kind }/${ name }`,
+										entityId
 									);
 								} );
 						},
@@ -287,6 +289,11 @@ export const getEntityRecord =
 								);
 							}
 						},
+						onUndoStackChange: ( undoState ) => {
+							dispatch.__unstableNotifySyncUndoManagerChange(
+								undoState
+							);
+						},
 						restoreUndoMeta: ( ydoc, meta ) => {
 							const selectionHistory =
 								meta.get( 'selectionHistory' );

package/src/selectors.ts

@@ -24,6 +24,7 @@ import {
 	isNumericID,
 	getUserPermissionCacheKey,
 } from './utils';
+import { getSyncManager } from './sync';
 import type * as ET from './entity-types';
 import logEntityDeprecation from './utils/log-entity-deprecation';
 
@@ -44,6 +45,10 @@ export interface State {
 	themeGlobalStyleVariations: Record< string, string >;
 	themeGlobalStyleRevisions: Record< number, Object >;
 	undoManager: UndoManager;
+	syncUndoManagerState: {
+		hasRedo: boolean;
+		hasUndo: boolean;
+	};
 	userPermissions: Record< string, boolean >;
 	users: UserState;
 	navigationFallbackId: EntityRecordKey;
@@ -1148,6 +1153,9 @@ export function getRedoEdit( state: State ): Optional< any > {
  * @return Whether there is a previous edit or not.
  */
 export function hasUndo( state: State ): boolean {
+	if ( getSyncManager()?.undoManager ) {
+		return state.syncUndoManagerState.hasUndo;
+	}
 	return getUndoManager( state ).hasUndo();
 }
 
@@ -1160,6 +1168,9 @@ export function hasUndo( state: State ): boolean {
  * @return Whether there is a next edit or not.
  */
 export function hasRedo( state: State ): boolean {
+	if ( getSyncManager()?.undoManager ) {
+		return state.syncUndoManagerState.hasRedo;
+	}
 	return getUndoManager( state ).hasRedo();
 }
 

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/test/private-selectors.js

@@ -0,0 +1,66 @@
+/**
+ * Internal dependencies
+ */
+import { getUndoManager } from '../private-selectors';
+import { getSyncManager } from '../sync';
+
+jest.mock( '../sync', () => ( {
+	getSyncManager: jest.fn(),
+} ) );
+
+describe( 'getUndoManager', () => {
+	afterEach( () => {
+		getSyncManager.mockReset();
+	} );
+
+	it( 'returns the sync undo manager when one is available', () => {
+		const syncUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		const fallbackUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( {
+			undoManager: syncUndoManager,
+		} );
+
+		const state = {
+			undoManager: fallbackUndoManager,
+			syncUndoManagerState: {
+				hasRedo: false,
+				hasUndo: false,
+			},
+		};
+
+		expect( getUndoManager( state ) ).toBe( syncUndoManager );
+	} );
+
+	it( 'returns the default undo manager when there is no sync undo manager', () => {
+		const fallbackUndoManager = {
+			addRecord: jest.fn(),
+			hasRedo: jest.fn(),
+			hasUndo: jest.fn(),
+			redo: jest.fn(),
+			undo: jest.fn(),
+		};
+		getSyncManager.mockReturnValue( undefined );
+
+		expect(
+			getUndoManager( {
+				undoManager: fallbackUndoManager,
+				syncUndoManagerState: {
+					hasRedo: false,
+					hasUndo: false,
+				},
+			} )
+		).toBe( fallbackUndoManager );
+	} );
+} );