@wordpress/core-data 7.40.2-next.v.202602241322.0 → 7.40.2

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

@@ -11,6 +11,9 @@ import {
 	useResolvedSelection,
 	useGetDebugData,
 	useIsDisconnected,
+	useOnCollaboratorJoin,
+	useOnCollaboratorLeave,
+	useOnPostSave,
 } from '../use-post-editor-awareness-state';
 import { getSyncManager } from '../../sync';
 import { SelectionType } from '../../utils/crdt-user-selections';
@@ -66,6 +69,9 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 		onStateChange: jest.Mock;
 		convertSelectionStateToAbsolute: jest.Mock;
 		getDebugData: jest.Mock;
+		doc: {
+			getMap: jest.Mock;
+		};
 	};
 	let mockSyncManager: {
 		getAwareness: jest.Mock;
@@ -73,9 +79,29 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 	let stateChangeCallback:
 		| ( ( newState: PostEditorAwarenessState[] ) => void )
 		| null;
+	let stateMapObserver:
+		| ( ( event: { keysChanged: Set< string > } ) => void )
+		| null;
+	let mockStateMapData: Record< string, unknown >;
+	let mockRecordMapData: Record< string, unknown >;
 
 	beforeEach( () => {
 		stateChangeCallback = null;
+		stateMapObserver = null;
+		mockStateMapData = {};
+		mockRecordMapData = {};
+
+		const mockStateMap = {
+			get: jest.fn( ( key: string ) => mockStateMapData[ key ] ),
+			observe: jest.fn( ( observer: typeof stateMapObserver ) => {
+				stateMapObserver = observer;
+			} ),
+			unobserve: jest.fn(),
+		};
+
+		const mockRecordMap = {
+			get: jest.fn( ( key: string ) => mockRecordMapData[ key ] ),
+		};
 
 		mockAwareness = {
 			setUp: jest.fn(),
@@ -86,6 +112,17 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 			} ),
 			convertSelectionStateToAbsolute: jest.fn().mockReturnValue( null ),
 			getDebugData: jest.fn().mockReturnValue( createMockDebugData() ),
+			doc: {
+				getMap: jest.fn( ( name: string ) => {
+					if ( name === 'state' ) {
+						return mockStateMap;
+					}
+					if ( name === 'document' ) {
+						return mockRecordMap;
+					}
+					return null;
+				} ),
+			},
 		};
 
 		mockSyncManager = {
@@ -256,7 +293,7 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 			};
 
 			expect( result.current( mockSelection ) ).toEqual( {
-				textIndex: null,
+				richTextOffset: null,
 				localClientId: null,
 			} );
 		} );
@@ -270,7 +307,7 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 				},
 			};
 			mockAwareness.convertSelectionStateToAbsolute.mockReturnValue( {
-				textIndex: 10,
+				richTextOffset: 10,
 				localClientId: 'block-1',
 			} );
 
@@ -284,7 +321,7 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 				mockAwareness.convertSelectionStateToAbsolute
 			).toHaveBeenCalledWith( mockSelection );
 			expect( position ).toEqual( {
-				textIndex: 10,
+				richTextOffset: 10,
 				localClientId: 'block-1',
 			} );
 		} );
@@ -481,4 +518,410 @@ describe( 'use-post-editor-awareness-state hooks', () => {
 			expect( result.current ).toBe( false );
 		} );
 	} );
+
+	describe( 'useOnCollaboratorJoin', () => {
+		const me = createMockActiveUser( {
+			clientId: 1,
+			isMe: true,
+			collaboratorInfo: {
+				id: 1,
+				name: 'Me',
+				slug: 'me',
+				avatar_urls: mockAvatarUrls,
+				browserType: 'Chrome',
+				enteredAt: 1704067200000,
+			},
+		} );
+
+		const alice = createMockActiveUser( {
+			clientId: 2,
+			isMe: false,
+			collaboratorInfo: {
+				id: 100,
+				name: 'Alice',
+				slug: 'alice',
+				avatar_urls: mockAvatarUrls,
+				browserType: 'Chrome',
+				enteredAt: 1704067300000,
+			},
+		} );
+
+		test( 'should not fire on initial mount', () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnCollaboratorJoin( 123, 'post', callback ) );
+
+			expect( callback ).not.toHaveBeenCalled();
+		} );
+
+		test( 'should not fire when collaborators load after initially empty state', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [] );
+
+			renderHook( () => useOnCollaboratorJoin( 123, 'post', callback ) );
+
+			// Simulate store hydration: collaborators appear
+			act( () => {
+				stateChangeCallback?.( [ me, alice ] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should fire callback when a new collaborator joins', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me ] );
+
+			renderHook( () => useOnCollaboratorJoin( 123, 'post', callback ) );
+
+			// Alice joins
+			act( () => {
+				stateChangeCallback?.( [ me, alice ] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledWith( alice, me );
+			} );
+		} );
+
+		test( 'should not fire callback for the current user', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [] );
+
+			renderHook( () => useOnCollaboratorJoin( 123, 'post', callback ) );
+
+			// First: hydrate with alice so prevCollaborators is non-empty
+			act( () => {
+				stateChangeCallback?.( [ alice ] );
+			} );
+
+			// Now "me" appears
+			act( () => {
+				stateChangeCallback?.( [ alice, me ] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should not fire when postId is null', () => {
+			const callback = jest.fn();
+
+			renderHook( () => useOnCollaboratorJoin( null, 'post', callback ) );
+
+			expect( callback ).not.toHaveBeenCalled();
+			expect( mockSyncManager.getAwareness ).not.toHaveBeenCalled();
+		} );
+	} );
+
+	describe( 'useOnCollaboratorLeave', () => {
+		const me = createMockActiveUser( {
+			clientId: 1,
+			isMe: true,
+		} );
+
+		const alice = createMockActiveUser( {
+			clientId: 2,
+			isMe: false,
+			isConnected: true,
+			collaboratorInfo: {
+				id: 100,
+				name: 'Alice',
+				slug: 'alice',
+				avatar_urls: mockAvatarUrls,
+				browserType: 'Chrome',
+				enteredAt: 1704067300000,
+			},
+		} );
+
+		test( 'should fire callback when a connected collaborator disconnects', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnCollaboratorLeave( 123, 'post', callback ) );
+
+			// Alice disconnects
+			act( () => {
+				stateChangeCallback?.( [
+					me,
+					{ ...alice, isConnected: false },
+				] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledWith( alice );
+			} );
+		} );
+
+		test( 'should fire callback when a connected collaborator disappears from the list', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnCollaboratorLeave( 123, 'post', callback ) );
+
+			// Alice disappears entirely
+			act( () => {
+				stateChangeCallback?.( [ me ] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledWith( alice );
+			} );
+		} );
+
+		test( 'should not fire callback when an already-disconnected collaborator is removed', async () => {
+			const callback = jest.fn();
+			const disconnectedAlice = { ...alice, isConnected: false };
+			mockAwareness.getCurrentState.mockReturnValue( [
+				me,
+				disconnectedAlice,
+			] );
+
+			renderHook( () => useOnCollaboratorLeave( 123, 'post', callback ) );
+
+			// Disconnected Alice is removed from list (cleanup after delay)
+			act( () => {
+				stateChangeCallback?.( [ me ] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should not fire callback for the current user disconnecting', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnCollaboratorLeave( 123, 'post', callback ) );
+
+			// "Me" disconnects
+			act( () => {
+				stateChangeCallback?.( [
+					{ ...me, isConnected: false },
+					alice,
+				] );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should not fire on initial mount', () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnCollaboratorLeave( 123, 'post', callback ) );
+
+			expect( callback ).not.toHaveBeenCalled();
+		} );
+	} );
+
+	describe( 'useOnPostSave', () => {
+		const me = createMockActiveUser( {
+			clientId: 1,
+			isMe: true,
+		} );
+
+		const alice = createMockActiveUser( {
+			clientId: 2,
+			isMe: false,
+			collaboratorInfo: {
+				id: 100,
+				name: 'Alice',
+				slug: 'alice',
+				avatar_urls: mockAvatarUrls,
+				browserType: 'Chrome',
+				enteredAt: 1704067300000,
+			},
+		} );
+
+		test( 'should fire callback when a remote collaborator saves', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnPostSave( 123, 'post', callback ) );
+
+			// Simulate a save event via the Y.Doc state map
+			const savedAt = Date.now() + 1000;
+			mockStateMapData = {
+				savedAt,
+				savedBy: alice.clientId,
+			};
+			mockRecordMapData = { status: 'draft' };
+
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledWith(
+					{
+						savedAt,
+						savedByClientId: alice.clientId,
+						postStatus: 'draft',
+					},
+					alice,
+					null
+				);
+			} );
+		} );
+
+		test( 'should pass previous save event on subsequent saves', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnPostSave( 123, 'post', callback ) );
+
+			// First save
+			const firstSavedAt = Date.now() + 1000;
+			mockStateMapData = {
+				savedAt: firstSavedAt,
+				savedBy: alice.clientId,
+			};
+			mockRecordMapData = { status: 'draft' };
+
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledTimes( 1 );
+			} );
+
+			// Second save
+			const secondSavedAt = Date.now() + 2000;
+			mockStateMapData = {
+				savedAt: secondSavedAt,
+				savedBy: alice.clientId,
+			};
+			mockRecordMapData = { status: 'publish' };
+
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledTimes( 2 );
+			} );
+
+			expect( callback ).toHaveBeenLastCalledWith(
+				{
+					savedAt: secondSavedAt,
+					savedByClientId: alice.clientId,
+					postStatus: 'publish',
+				},
+				alice,
+				{
+					savedAt: firstSavedAt,
+					savedByClientId: alice.clientId,
+					postStatus: 'draft',
+				}
+			);
+		} );
+
+		test( 'should not fire callback when the current user saves', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnPostSave( 123, 'post', callback ) );
+
+			// Simulate a save event by "me"
+			const savedAt = Date.now() + 1000;
+			mockStateMapData = {
+				savedAt,
+				savedBy: me.clientId,
+			};
+			mockRecordMapData = { status: 'draft' };
+
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should not fire callback when saver is not in the collaborator list', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me ] );
+
+			renderHook( () => useOnPostSave( 123, 'post', callback ) );
+
+			// Simulate a save from an unknown client
+			const savedAt = Date.now() + 1000;
+			mockStateMapData = {
+				savedAt,
+				savedBy: 99999,
+			};
+			mockRecordMapData = { status: 'draft' };
+
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).not.toHaveBeenCalled();
+			} );
+		} );
+
+		test( 'should not fire duplicate callbacks for the same savedAt timestamp', async () => {
+			const callback = jest.fn();
+			mockAwareness.getCurrentState.mockReturnValue( [ me, alice ] );
+
+			renderHook( () => useOnPostSave( 123, 'post', callback ) );
+
+			const savedAt = Date.now() + 1000;
+			mockStateMapData = {
+				savedAt,
+				savedBy: alice.clientId,
+			};
+			mockRecordMapData = { status: 'draft' };
+
+			// First save event
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			await waitFor( () => {
+				expect( callback ).toHaveBeenCalledTimes( 1 );
+			} );
+
+			// Same savedAt again (e.g. component re-render)
+			act( () => {
+				stateMapObserver?.( {
+					keysChanged: new Set( [ 'savedAt' ] ),
+				} );
+			} );
+
+			// Should still be 1 call
+			expect( callback ).toHaveBeenCalledTimes( 1 );
+		} );
+
+		test( 'should not fire when postId is null', () => {
+			const callback = jest.fn();
+
+			renderHook( () => useOnPostSave( null, 'post', callback ) );
+
+			expect( callback ).not.toHaveBeenCalled();
+		} );
+	} );
 } );

package/src/hooks/use-entity-prop.js

@@ -1,13 +1,15 @@
 /**
  * WordPress dependencies
  */
-import { useCallback } from '@wordpress/element';
+import { useCallback, useContext } from '@wordpress/element';
 import { useDispatch, useSelect } from '@wordpress/data';
 
 /**
  * Internal dependencies
  */
 import { STORE_NAME } from '../name';
+import { DEFAULT_ENTITY_KEY } from '../entities';
+import { EntityContext } from '../entity-context';
 import useEntityId from './use-entity-id';
 
 /**
@@ -30,9 +32,44 @@ import useEntityId from './use-entity-id';
 export default function useEntityProp( kind, name, prop, _id ) {
 	const providerId = useEntityId( kind, name );
 	const id = _id ?? providerId;
+	const context = useContext( EntityContext );
+	const revisionId = context?.revisionId;
 
 	const { value, fullValue } = useSelect(
 		( select ) => {
+			if ( revisionId ) {
+				// Use getRevisions (not getRevision) to read from the
+				// already-cached collection. Using getRevision would
+				// trigger a redundant single-revision API fetch that
+				// can wipe the collection due to a race condition.
+				// See https://github.com/WordPress/gutenberg/pull/76043.
+				const revisions = select( STORE_NAME ).getRevisions(
+					kind,
+					name,
+					id,
+					{
+						per_page: -1,
+						context: 'edit',
+						_fields:
+							'id,date,author,meta,title.raw,excerpt.raw,content.raw',
+					}
+				);
+				const entityConfig = select( STORE_NAME ).getEntityConfig(
+					kind,
+					name
+				);
+				const revKey = entityConfig?.revisionKey || DEFAULT_ENTITY_KEY;
+				const revision = revisions?.find(
+					( r ) => r[ revKey ] === revisionId
+				);
+				return revision
+					? {
+							value: revision[ prop ]?.raw ?? revision[ prop ],
+							fullValue: revision[ prop ],
+					  }
+					: {};
+			}
+
 			const { getEntityRecord, getEditedEntityRecord } =
 				select( STORE_NAME );
 			const record = getEntityRecord( kind, name, id ); // Trigger resolver.
@@ -44,16 +81,19 @@ export default function useEntityProp( kind, name, prop, _id ) {
 				  }
 				: {};
 		},
-		[ kind, name, id, prop ]
+		[ kind, name, id, prop, revisionId ]
 	);
 	const { editEntityRecord } = useDispatch( STORE_NAME );
 	const setValue = useCallback(
 		( newValue ) => {
+			if ( revisionId ) {
+				return;
+			}
 			editEntityRecord( kind, name, id, {
 				[ prop ]: newValue,
 			} );
 		},
-		[ editEntityRecord, kind, name, id, prop ]
+		[ editEntityRecord, kind, name, id, prop, revisionId ]
 	);
 
 	return [ value, setValue, fullValue ];