@wordpress/core-data 7.46.0 → 7.48.0

package/src/hooks/test/use-resource-permissions.js

@@ -127,6 +127,63 @@ describe( 'useResourcePermissions', () => {
 		);
 	} );
 
+	it( 'normalizes id-less entity resources before resolving permissions', async () => {
+		let data;
+		triggerFetch.mockImplementation( ( options ) => {
+			if ( options.path === '/wp/v2/types?context=view' ) {
+				return {
+					wp_navigation: {
+						name: 'Navigation Menus',
+						slug: 'wp_navigation',
+						rest_base: 'navigation',
+						rest_namespace: 'wp/v2',
+					},
+				};
+			}
+			if (
+				options.path === '/wp/v2/navigation' &&
+				options.method === 'OPTIONS'
+			) {
+				return {
+					headers: new Headers( { allow: 'GET, POST' } ),
+				};
+			}
+			throw new Error(
+				`Unexpected request: ${ JSON.stringify( options ) }`
+			);
+		} );
+
+		const TestComponent = () => {
+			data = useResourcePermissions( {
+				kind: 'postType',
+				name: 'wp_navigation',
+				id: undefined,
+			} );
+			return <div />;
+		};
+		render(
+			<RegistryProvider value={ registry }>
+				<TestComponent />
+			</RegistryProvider>
+		);
+
+		await waitFor( () =>
+			expect( data ).toEqual( {
+				status: 'SUCCESS',
+				isResolving: false,
+				hasResolved: true,
+				canCreate: true,
+				canRead: true,
+			} )
+		);
+
+		expect(
+			triggerFetch.mock.calls.filter(
+				( [ options ] ) => options.path === '/wp/v2/navigation'
+			)
+		).toHaveLength( 1 );
+	} );
+
 	it( 'retrieves the relevant permissions for an entity', async () => {
 		let data;
 		const TestComponent = () => {

package/src/hooks/use-entity-block-editor.js

@@ -11,9 +11,9 @@ import { parse, __unstableSerializeAndClean } from '@wordpress/blocks';
 import { STORE_NAME } from '../name';
 import useEntityId from './use-entity-id';
 import { updateFootnotesFromMeta } from '../footnotes';
+import { parsedBlocksCache, getCacheKey } from '../parsed-blocks-cache';
 
 const EMPTY_ARRAY = [];
-const parsedBlocksCache = new Map();
 
 /**
  * Hook that returns block content getters and setters for
@@ -69,7 +69,7 @@ export default function useEntityBlockEditor( kind, name, { id: _id } = {} ) {
 
 		// Cache parsed blocks by entity identity. Store the content
 		// alongside the blocks so we can validate it hasn't changed.
-		const cacheKey = `${ kind }:${ name }:${ id }`;
+		const cacheKey = getCacheKey( kind, name, id );
 		const cached = parsedBlocksCache.get( cacheKey );
 		let _blocks;
 

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

@@ -27,6 +27,7 @@ interface AwarenessState {
 const defaultResolvedSelection: ResolvedSelection = {
 	richTextOffset: null,
 	localClientId: null,
+	attributeKey: null,
 };
 
 const defaultState: AwarenessState = {

package/src/hooks/use-resource-permissions.ts

@@ -145,15 +145,13 @@ function useResourcePermissions< IdType = void >(
 		( resolve ) => {
 			const hasId = isEntity ? !! resource.id : !! id;
 			const { canUser } = resolve( coreStore );
-			const create = canUser(
-				'create',
-				isEntity
-					? { kind: resource.kind, name: resource.name }
-					: resource
-			);
+			const collectionResource = isEntity
+				? { kind: resource.kind, name: resource.name }
+				: resource;
+			const create = canUser( 'create', collectionResource );
 
 			if ( ! hasId ) {
-				const read = canUser( 'read', resource );
+				const read = canUser( 'read', collectionResource );
 
 				const isResolving = create.isResolving || read.isResolving;
 				const hasResolved = create.hasResolved && read.hasResolved;

package/src/index.js

@@ -133,13 +133,6 @@ unlock( store ).registerPrivateSelectors( privateSelectors );
 unlock( store ).registerPrivateActions( privateActions );
 register( store ); // Register store after unlocking private selectors to allow resolvers to use them.
 
-/**
- * Enums cannot be exported private without losing the ability to narrow types
- * based on their values (they blur to string type).
- */
-export { SelectionType } from './utils/crdt-user-selections';
-export { SelectionDirection } from './types';
-
 export { default as EntityProvider } from './entity-provider';
 export * from './entity-provider';
 export * from './entity-types';

package/src/parsed-blocks-cache.js

@@ -0,0 +1,12 @@
+/**
+ * Shared cache of blocks parsed from an entity's `content` string, keyed by
+ * `kind:name:id`. Populated both eagerly by the `getEntityRecord` resolver
+ * (when the sync manager parses content for transient edits) and lazily by
+ * `useEntityBlockEditor`. The stored `content` string acts as a validator so
+ * stale entries are discarded when the underlying record changes.
+ */
+export const parsedBlocksCache = new Map();
+
+export function getCacheKey( kind, name, id ) {
+	return `${ kind }:${ name }:${ id }`;
+}

package/src/private-actions.js

@@ -7,6 +7,7 @@ import apiFetch from '@wordpress/api-fetch';
  * Internal dependencies
  */
 import { STORE_NAME } from './name';
+import { getSyncManager, hasSyncManager } from './sync';
 
 /**
  * Returns an action object used in signalling that the registered post meta
@@ -163,6 +164,7 @@ export function receiveEditorAssets( assets ) {
 
 /**
  * Returns an action object used to set whether collaboration is supported.
+ * When set to false, also disconnects all sync entities.
  *
  * @param {boolean} supported Whether collaboration is supported.
  *
@@ -172,6 +174,9 @@ export const setCollaborationSupported =
 	( supported ) =>
 	( { dispatch } ) => {
 		dispatch( { type: 'SET_COLLABORATION_SUPPORTED', supported } );
+		if ( ! supported && hasSyncManager() ) {
+			getSyncManager().unloadAll();
+		}
 	};
 
 /**
@@ -191,3 +196,32 @@ export function receiveViewConfig( kind, name, config ) {
 		config,
 	};
 }
+
+/**
+ * Returns an action object used to set the sync connection status for an entity or collection.
+ *
+ * @param {string}             kind   Kind of the entity.
+ * @param {string}             name   Name of the entity.
+ * @param {number|string|null} key    The entity key, or null for collections.
+ * @param {Object|null}        status The connection state object or null on unload.
+ *
+ * @return {Object} Action object.
+ */
+export function setSyncConnectionStatus( kind, name, key, status ) {
+	if ( ! status ) {
+		return {
+			type: 'CLEAR_SYNC_CONNECTION_STATUS',
+			kind,
+			name,
+			key,
+		};
+	}
+
+	return {
+		type: 'SET_SYNC_CONNECTION_STATUS',
+		kind,
+		name,
+		key,
+		status,
+	};
+}

package/src/{private-apis.js → private-apis.ts}

@@ -12,9 +12,12 @@ import {
 } from './hooks/use-post-editor-awareness-state';
 import { lock } from './lock-unlock';
 import { retrySyncConnection } from './sync';
+import {
+	SelectionType,
+	SelectionDirection,
+} from './utils/crdt-user-selections';
 
-export const privateApis = {};
-lock( privateApis, {
+const lockedApis = {
 	useEntityRecordsWithPermissions,
 	RECEIVE_INTERMEDIATE_RESULTS,
 	retrySyncConnection,
@@ -23,4 +26,11 @@ lock( privateApis, {
 	useOnCollaboratorJoin,
 	useOnCollaboratorLeave,
 	useOnPostSave,
-} );
+	SelectionType,
+	SelectionDirection,
+};
+
+export type CoreDataPrivateApis = typeof lockedApis;
+
+export const privateApis = {};
+lock( privateApis, lockedApis );

package/src/private-selectors.ts

@@ -2,6 +2,7 @@
  * WordPress dependencies
  */
 import { createSelector, createRegistrySelector } from '@wordpress/data';
+import type { ConnectionStatus } from '@wordpress/sync';
 
 /**
  * Internal dependencies
@@ -347,3 +348,35 @@ export function getViewConfig(
 		}
 	);
 }
+
+/**
+ * Returns the current sync connection status across all entities. Prioritizes
+ * disconnected states, then connecting, then connected.
+ *
+ * @param state Data state.
+ *
+ * @return The current sync connection state, prioritized by importance.
+ */
+export function getSyncConnectionStatus(
+	state: State
+): ConnectionStatus | undefined {
+	if ( ! state.syncConnectionStatuses ) {
+		return undefined;
+	}
+
+	const PRIORITIZED_STATUSES = [ 'disconnected', 'connecting', 'connected' ];
+
+	let coalesced: ConnectionStatus | undefined;
+
+	for ( const status of Object.values( state.syncConnectionStatuses ) ) {
+		if (
+			! coalesced ||
+			PRIORITIZED_STATUSES.indexOf( status.status ) <
+				PRIORITIZED_STATUSES.indexOf( coalesced.status )
+		) {
+			coalesced = status;
+		}
+	}
+
+	return coalesced;
+}

package/src/resolvers.js

@@ -28,6 +28,7 @@ import {
 } from './utils';
 import { fetchBlockPatterns } from './fetch';
 import { restoreSelection, getSelectionHistory } from './utils/crdt-selection';
+import { parsedBlocksCache, getCacheKey } from './parsed-blocks-cache';
 
 /**
  * Requests authors from the REST API.
@@ -180,6 +181,18 @@ export const getEntityRecord =
 							transientConfig.read( recordWithTransients );
 					} );
 
+				// Share the parsed blocks with `useEntityBlockEditor` so the
+				// editor doesn't re-parse the same `content` string.
+				if (
+					recordWithTransients.blocks &&
+					typeof recordWithTransients.content?.raw === 'string'
+				) {
+					parsedBlocksCache.set( getCacheKey( kind, name, key ), {
+						content: recordWithTransients.content.raw,
+						blocks: recordWithTransients.blocks,
+					} );
+				}
+
 				// Load the entity record for syncing. Do not await promise.
 				void getSyncManager()?.load(
 					entityConfig.syncConfig,
@@ -247,13 +260,18 @@ export const getEntityRecord =
 										return;
 									}
 
-									// Trigger a 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.
+									// 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,
-										editedRecord,
+										{
+											[ entityIdKey ]:
+												editedRecord[ entityIdKey ],
+										},
 										{ __unstableSkipSyncUpdate: true }
 									);
 								} );
@@ -1014,10 +1032,14 @@ export const getDefaultTemplateId =
 	};
 
 getDefaultTemplateId.shouldInvalidate = ( action ) => {
+	// Only invalidate on real saves; `persistedEdits` is absent on
+	// initial fetches so the kickoff's own site read doesn't wipe
+	// the just-resolved template id.
 	return (
 		action.type === 'RECEIVE_ITEMS' &&
 		action.kind === 'root' &&
-		action.name === 'site'
+		action.name === 'site' &&
+		!! action.persistedEdits
 	);
 };
 

package/src/selectors.ts

@@ -1661,35 +1661,3 @@ export const getRevision = createSelector(
 		];
 	}
 );
-
-/**
- * Returns the current sync connection status across all entities. Prioritizes
- * disconnected states, then connecting, then connected.
- *
- * @param state Data state.
- *
- * @return The current sync connection state, prioritized by importance.
- */
-export function getSyncConnectionStatus(
-	state: State
-): ConnectionStatus | undefined {
-	if ( ! state.syncConnectionStatuses ) {
-		return undefined;
-	}
-
-	const PRIORITIZED_STATUSES = [ 'disconnected', 'connecting', 'connected' ];
-
-	let coalesced: ConnectionStatus | undefined;
-
-	for ( const status of Object.values( state.syncConnectionStatuses ) ) {
-		if (
-			! coalesced ||
-			PRIORITIZED_STATUSES.indexOf( status.status ) <
-				PRIORITIZED_STATUSES.indexOf( coalesced.status )
-		) {
-			coalesced = status;
-		}
-	}
-
-	return coalesced;
-}

package/src/sync.ts

@@ -43,3 +43,12 @@ export function getSyncManager(): SyncManager | undefined {
 
 	return syncManager;
 }
+
+/**
+ * Return whether a sync manager has already been created. Use this when you
+ * only want to interact with an existing sync manager (e.g. to tear it down),
+ * without `getSyncManager()` bootstrapping one if none exists.
+ */
+export function hasSyncManager(): boolean {
+	return Boolean( syncManager );
+}

package/src/test/resolvers.js

@@ -234,9 +234,14 @@ describe( 'getEntityRecord', () => {
 		expect( dispatch.saveEntityRecord ).not.toHaveBeenCalled();
 	} );
 
-	it( 'persistCRDTDoc fetches edited record and saves full entity record', async () => {
+	it( 'persistCRDTDoc saves only the entity ID and omits REST-invalid fields', async () => {
 		const POST_RECORD = { id: 1, title: 'Test Post', meta: {} };
-		const EDITED_RECORD = { id: 1, title: 'Edited Post', meta: {} };
+		const EDITED_RECORD = {
+			id: 1,
+			title: 'Edited Post',
+			ping_status: '',
+			meta: { _crdt_document: 'doc2' },
+		};
 		const POST_RESPONSE = {
 			json: () => Promise.resolve( POST_RECORD ),
 		};
@@ -283,11 +288,12 @@ describe( 'getEntityRecord', () => {
 			resolveSelectWithSync.getEditedEntityRecord
 		).toHaveBeenCalledWith( 'postType', 'post', 1 );
 
-		// Should have called saveEntityRecord (not saveEditedEntityRecord).
+		// Should only send the entity ID. The pre-persist hook creates the
+		// persisted CRDT meta without round-tripping the full edited record.
 		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
 			'postType',
 			'post',
-			EDITED_RECORD,
+			{ id: 1 },
 			{ __unstableSkipSyncUpdate: true }
 		);
 	} );
@@ -335,11 +341,11 @@ describe( 'getEntityRecord', () => {
 		handlers.persistCRDTDoc();
 		await resolveSelectWithSync.getEditedEntityRecord();
 
-		// Should save the record even with no edits (the whole point of the fix).
+		// Should save only the entity ID even with no edits.
 		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
 			'postType',
 			'post',
-			POST_RECORD,
+			{ id: 1 },
 			{ __unstableSkipSyncUpdate: true }
 		);
 	} );
@@ -437,7 +443,7 @@ describe( 'getEntityRecord', () => {
 		expect( dispatch.saveEntityRecord ).toHaveBeenCalledWith(
 			'postType',
 			'post',
-			EDITED_RECORD,
+			{ id: 1 },
 			{ __unstableSkipSyncUpdate: true }
 		);
 		expect( syncManager.update ).toHaveBeenCalledWith(

package/src/types.ts

@@ -6,7 +6,10 @@ import type { ConnectionStatusDisconnected, Y } from '@wordpress/sync';
 /**
  * Internal dependencies
  */
-import type { SelectionType } from './utils/crdt-user-selections';
+import type {
+	SelectionType,
+	SelectionDirection,
+} from './utils/crdt-user-selections';
 
 export type { ConnectionStatus } from '@wordpress/sync';
 
@@ -127,17 +130,11 @@ export type CursorPosition = {
 	// character. With both of these values as editor state, a change in perceived
 	// position will always result in a redraw.
 	absoluteOffset: number;
-};
 
-/**
- * The direction of a text selection, indicating where the caret sits.
- */
-export enum SelectionDirection {
-	/** The caret is at the end of the selection (default / left-to-right). */
-	Forward = 'f',
-	/** The caret is at the start of the selection (right-to-left). */
-	Backward = 'b',
-}
+	// The sender's `WPBlockSelection.attributeKey` (e.g. `content` or
+	// `body.0.cells.0.content`).
+	attributeKey?: string;
+};
 
 export type SelectionNone = {
 	// The user has not made a selection.
@@ -192,4 +189,12 @@ export type SelectionState =
 export interface ResolvedSelection {
 	richTextOffset: number | null;
 	localClientId: string | null;
+
+	// Identifier of the RichText attribute within the block, e.g.:
+	// - `content` on a core/paragraph block
+	// - `citation` on a quote block
+	// - a dot path into a nested attribute like `body.0.cells.0.content` for a
+	//   core/table cell.
+	// Set to `null` for WholeBlock selections.
+	attributeKey: string | null;
 }

package/src/utils/block-selection-history.ts

@@ -12,6 +12,7 @@ import { Y } from '@wordpress/sync';
 import {
 	asRichTextOffset,
 	findBlockByClientIdInDoc,
+	getYTextByAttributeKey,
 	richTextOffsetToHtmlIndex,
 } from './crdt-utils';
 import type { WPBlockSelection, WPSelection } from '../types';
@@ -147,14 +148,16 @@ function convertWPBlockSelectionToSelection(
 	const attributes = block?.get( 'attributes' );
 	const attributeKey = selection.attributeKey;
 
-	const changedYText = attributeKey
-		? attributes?.get( attributeKey )
-		: undefined;
-
-	const isYText = changedYText instanceof Y.Text;
-	const isFullyDefinedSelection = attributeKey && clientId;
+	let changedYText: Y.Text | null = null;
+	if ( attributeKey && attributes ) {
+		changedYText = getYTextByAttributeKey( attributes, attributeKey );
+	}
 
-	if ( ! isYText || ! isFullyDefinedSelection ) {
+	if (
+		! ( changedYText instanceof Y.Text ) ||
+		! attributeKey ||
+		! clientId
+	) {
 		// We either don't have a valid YText (it's been deleted) or we've
 		// been passed a selection that's just a block clientId.
 		// Store as BlockSelection.

package/src/utils/crdt-blocks.ts

@@ -599,6 +599,30 @@ export function mergeCrdtBlocks(
 						break;
 					}
 
+					case 'clientId': {
+						// Never overwrite the local block's clientId with the
+						// incoming one. Some callers (e.g. the Code Editor flow
+						// that parses raw HTML into blocks on every keystroke)
+						// produce randomized clientIds for blocks whose content
+						// has changed on every sync. Without this case the default
+						// branch would replace the stable Y.Doc clientId with
+						// a new one, causing remote peers to remount the block
+						// and flash the block's content on reload.
+						//
+						// This mirrors the clientId exclusion in `areBlocksEqual`.
+						// Convergence is preserved. Because we're not writing
+						// to the clientId, Yjs doesn't send an update to peers
+						// telling them to change the clientId, so everyone
+						// sees the same clientId per block.
+						// Inserts still use a new clientId via createNewYBlock,
+						// and the duplicate-clientId sweep below catches any
+						// edge cases. The clientId is anchored to the
+						// slot in the array rather than to specific content,
+						// which is consistent with areBlocksEqual ignoring
+						// clientId when diffing.
+						break;
+					}
+
 					default:
 						if (
 							! fastDeepEqual(

package/src/utils/crdt-user-selections.ts

@@ -15,6 +15,7 @@ import type { YBlock, YBlocks } from './crdt-blocks';
 import {
 	asRichTextOffset,
 	getRootMap,
+	getYTextByAttributeKey,
 	richTextOffsetToHtmlIndex,
 } from './crdt-utils';
 import type {
@@ -26,7 +27,6 @@ import type {
 	SelectionInOneBlock,
 	SelectionInMultipleBlocks,
 	SelectionWholeBlock,
-	SelectionDirection,
 	CursorPosition,
 } from '../types';
 
@@ -41,6 +41,16 @@ export enum SelectionType {
 	WholeBlock = 'whole-block',
 }
 
+/**
+ * The direction of a text selection, indicating where the caret sits.
+ */
+export enum SelectionDirection {
+	/** The caret is at the end of the selection (default / left-to-right). */
+	Forward = 'f',
+	/** The caret is at the start of the selection (right-to-left). */
+	Backward = 'b',
+}
+
 /**
  * Converts WordPress block editor selection to a SelectionState.
  *
@@ -173,7 +183,9 @@ function getCursorPosition(
 	}
 
 	const attributes = block.get( 'attributes' );
-	const currentYText = attributes?.get( selection.attributeKey );
+	const currentYText = attributes
+		? getYTextByAttributeKey( attributes, selection.attributeKey )
+		: null;
 
 	// If the attribute is not a Y.Text, return null.
 	if ( ! ( currentYText instanceof Y.Text ) ) {
@@ -191,6 +203,7 @@ function getCursorPosition(
 	return {
 		relativePosition,
 		absoluteOffset: selection.offset,
+		attributeKey: selection.attributeKey,
 	};
 }
 

package/src/utils/crdt-utils.ts

@@ -125,6 +125,47 @@ export function asHtmlStringIndex( index: number ): HtmlStringIndex {
 	return index as HtmlStringIndex;
 }
 
+/**
+ * Resolve a selection attribute key to a Y.Text value.
+ *
+ * RichText identifiers are normally top-level block attribute keys, but nested
+ * rich-text fields can provide a dot path such as `body.0.cells.0.content`.
+ *
+ * @param attributes   The block attributes map.
+ * @param attributeKey The top-level attribute key or nested attribute path.
+ * @return The matching Y.Text, or null if the path is not a rich-text field.
+ */
+export function getYTextByAttributeKey(
+	attributes: Y.Map< unknown >,
+	attributeKey: string
+): Y.Text | null {
+	const directValue = attributes.get( attributeKey );
+	if ( directValue instanceof Y.Text ) {
+		return directValue;
+	}
+
+	let value: unknown = attributes;
+	for ( const pathPart of attributeKey.split( '.' ) ) {
+		if ( value instanceof Y.Map ) {
+			value = value.get( pathPart );
+		} else if ( value instanceof Y.Array ) {
+			const index = Number.parseInt( pathPart, 10 );
+			if (
+				! Number.isSafeInteger( index ) ||
+				index < 0 ||
+				index.toString() !== pathPart
+			) {
+				return null;
+			}
+			value = value.get( index );
+		} else {
+			return null;
+		}
+	}
+
+	return value instanceof Y.Text ? value : null;
+}
+
 /**
  * Given a block ID and a Y.Doc, find the block in the document.
  *