@wordpress/core-data 7.50.1-next.v.202607070741.0 → 7.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/core-data",
-	"version": "7.50.1-next.v.202607070741.0+a51d59513",
+	"version": "7.52.0",
 	"description": "Access to and manipulation of core WordPress entities.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -48,41 +48,46 @@
 		"build-module/index.mjs"
 	],
 	"dependencies": {
-		"@wordpress/api-fetch": "^7.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/block-editor": "^16.0.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/blocks": "^15.23.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/compose": "^8.3.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/data": "^10.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/deprecated": "^4.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/element": "^8.2.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/html-entities": "^4.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/i18n": "^6.23.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/is-shallow-equal": "^5.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/private-apis": "^1.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/rich-text": "^7.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/sync": "^1.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/undo-manager": "^1.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/url": "^4.50.1-next.v.202607070741.0+a51d59513",
-		"@wordpress/warning": "^3.50.1-next.v.202607070741.0+a51d59513",
+		"@wordpress/api-fetch": "^7.52.0",
+		"@wordpress/block-editor": "^16.1.0",
+		"@wordpress/blocks": "^15.25.0",
+		"@wordpress/components": "^38.0.0",
+		"@wordpress/compose": "^8.5.0",
+		"@wordpress/data": "^10.52.0",
+		"@wordpress/deprecated": "^4.52.0",
+		"@wordpress/element": "^8.4.0",
+		"@wordpress/global-styles-engine": "^1.19.0",
+		"@wordpress/html-entities": "^4.52.0",
+		"@wordpress/i18n": "^6.25.0",
+		"@wordpress/icons": "^15.3.0",
+		"@wordpress/is-shallow-equal": "^5.52.0",
+		"@wordpress/notices": "^5.52.0",
+		"@wordpress/private-apis": "^1.52.0",
+		"@wordpress/rich-text": "^7.52.0",
+		"@wordpress/sync": "^1.52.0",
+		"@wordpress/undo-manager": "^1.52.0",
+		"@wordpress/url": "^4.52.0",
+		"@wordpress/warning": "^3.52.0",
 		"change-case": "^4.1.2",
+		"clsx": "^2.1.1",
 		"equivalent-key-map": "^0.2.2",
 		"fast-deep-equal": "^3.1.3",
-		"memize": "^2.1.0",
+		"memize": "^2.1.1",
 		"uuid": "^14.0.0"
 	},
 	"devDependencies": {
-		"@jest/globals": "^30.2.0",
+		"@jest/globals": "^30.4.1",
 		"@testing-library/dom": "^10.4.1",
 		"@testing-library/react": "^16.3.2",
-		"@types/jest": "^29.5.14",
+		"@types/jest": "^30.0.0",
 		"@types/node": "^20.19.39",
-		"@wordpress/block-library": "^10.1.1-next.v.202607070741.0+a51d59513",
+		"@wordpress/block-library": "^10.3.0",
 		"deep-freeze": "^0.0.1"
 	},
 	"peerDependencies": {
-		"@types/react": "^18.3.27",
-		"react": "^18.0.0",
-		"react-dom": "^18.0.0"
+		"@types/react": "^18 || ^19",
+		"react": "^18 || ^19",
+		"react-dom": "^18 || ^19"
 	},
 	"peerDependenciesMeta": {
 		"@types/react": {
@@ -92,5 +97,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "f637726e370c8b23695ed9af82adbe171ad235d8"
+	"gitHead": "7e8b17a983f9391d3ebc7717af2a1c9ed7efc7ab"
 }

package/src/actions.js

@@ -1,6 +1,7 @@
 /**
  * External dependencies
  */
+import fastDeepEqual from 'fast-deep-equal/es6/index.js';
 import { v4 as uuid } from 'uuid';
 
 /**
@@ -24,11 +25,71 @@ import {
 	getSyncManager,
 } from './sync';
 import logEntityDeprecation from './utils/log-entity-deprecation';
+import {
+	getRawValue,
+	POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE,
+} from './utils/crdt';
 
 function addTitleToAutoDraft( record ) {
 	return record.status === 'auto-draft' ? { ...record, title: '' } : record;
 }
 
+// Post meta is applied to the CRDT one subkey at a time, so compare the save
+// response at the same granularity to avoid carrying stale sibling values.
+function getServerMutatedMetaFields( updatedMeta, persistedMeta, syncedMeta ) {
+	const baseline = { ...persistedMeta, ...syncedMeta };
+
+	return Object.fromEntries(
+		Object.entries( updatedMeta ?? {} ).filter( ( [ key, value ] ) => {
+			if ( key === POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE ) {
+				// The persisted CRDT snapshot may change on save and is
+				// intentionally excluded from CRDT meta synchronization, so it
+				// is not a server mutation.
+				return false;
+			}
+
+			return ! fastDeepEqual( value, baseline[ key ] );
+		} )
+	);
+}
+
+function getServerMutatedFields(
+	updatedRecord,
+	persistedRecord,
+	syncedChanges
+) {
+	return Object.fromEntries(
+		Object.entries( updatedRecord ).flatMap( ( [ key, value ] ) => {
+			if ( key === 'meta' ) {
+				const serverMutatedMeta = getServerMutatedMetaFields(
+					value,
+					persistedRecord.meta,
+					syncedChanges.meta
+				);
+
+				return Object.keys( serverMutatedMeta ).length
+					? [ [ key, serverMutatedMeta ] ]
+					: [];
+			}
+
+			const baseline =
+				key in syncedChanges
+					? syncedChanges[ key ]
+					: persistedRecord[ key ];
+
+			// The save response nests raw attributes as `{ raw, rendered }`
+			// while the baseline holds raw strings; compare raw values so the
+			// shape difference does not read as a server mutation.
+			const wasServerMutated = ! fastDeepEqual(
+				getRawValue( value ) ?? value,
+				getRawValue( baseline ) ?? baseline
+			);
+
+			return wasServerMutated ? [ [ key, value ] ] : [];
+		} )
+	);
+}
+
 /**
  * Returns an action object used in signalling that authors have been received.
  * Ignored from documentation as it's internal to the data store.
@@ -759,6 +820,23 @@ export const saveEntityRecord =
 						);
 					}
 				} else {
+					// `saveEntityRecord` can be called directly, bypassing
+					// `editEntityRecord`, so make sure its changes enter the
+					// CRDT before the persisted document is created below.
+					if (
+						entityConfig.syncConfig &&
+						! __unstableSkipSyncUpdate &&
+						! isNewRecord &&
+						persistedRecord
+					) {
+						getSyncManager()?.update(
+							`${ kind }/${ name }`,
+							recordId,
+							record,
+							LOCAL_UNDO_IGNORED_ORIGIN
+						);
+					}
+
 					let edits = record;
 					if ( entityConfig.__unstablePrePersist ) {
 						edits = {
@@ -783,12 +861,25 @@ export const saveEntityRecord =
 						edits
 					);
 					if ( entityConfig.syncConfig ) {
+						let syncChanges;
+						if ( __unstableSkipSyncUpdate ) {
+							syncChanges = {};
+						} else if ( isNewRecord || ! persistedRecord ) {
+							syncChanges = updatedRecord;
+						} else {
+							syncChanges = getServerMutatedFields(
+								updatedRecord,
+								persistedRecord,
+								record
+							);
+						}
+
 						// Use an untracked origin so that the save
 						// response does not create undo levels.
 						getSyncManager()?.update(
 							`${ kind }/${ name }`,
 							recordId,
-							__unstableSkipSyncUpdate ? {} : updatedRecord,
+							syncChanges,
 							LOCAL_UNDO_IGNORED_ORIGIN,
 							{ isSave: true }
 						);

package/src/components/entities-saved-states/entity-record-item.js

@@ -0,0 +1,60 @@
+/**
+ * WordPress dependencies
+ */
+import { CheckboxControl, PanelRow } from '@wordpress/components';
+import { __ } from '@wordpress/i18n';
+import { useSelect } from '@wordpress/data';
+import { decodeEntities } from '@wordpress/html-entities';
+
+/**
+ * Internal dependencies
+ */
+import { STORE_NAME } from '../../name';
+import { getTemplateInfo } from '../../utils/get-template-info';
+
+export default function EntityRecordItem( { record, checked, onChange } ) {
+	const { name, kind, title, key } = record;
+
+	// Handle templates that might use default descriptive titles.
+	const { entityRecordTitle } = useSelect(
+		( select ) => {
+			if ( 'postType' !== kind || 'wp_template' !== name ) {
+				return {
+					entityRecordTitle: title,
+				};
+			}
+
+			const template = select( STORE_NAME ).getEditedEntityRecord(
+				kind,
+				name,
+				key
+			);
+
+			const { default_template_types: templateTypes = [] } =
+				select( STORE_NAME ).getCurrentTheme() ?? {};
+
+			return {
+				entityRecordTitle: getTemplateInfo( {
+					template,
+					templateTypes,
+				} ).title,
+			};
+		},
+		[ name, kind, title, key ]
+	);
+
+	return (
+		<>
+			<PanelRow>
+				<CheckboxControl
+					label={
+						decodeEntities( entityRecordTitle ) || __( 'Untitled' )
+					}
+					checked={ checked }
+					onChange={ onChange }
+					className="entities-saved-states__change-control"
+				/>
+			</PanelRow>
+		</>
+	);
+}

package/src/components/entities-saved-states/entity-type-list.js

@@ -0,0 +1,130 @@
+/**
+ * WordPress dependencies
+ */
+import { __ } from '@wordpress/i18n';
+import { useSelect } from '@wordpress/data';
+import { PanelBody, PanelRow } from '@wordpress/components';
+import { getGlobalStylesChanges } from '@wordpress/global-styles-engine';
+
+/**
+ * Internal dependencies
+ */
+import EntityRecordItem from './entity-record-item';
+import { STORE_NAME } from '../../name';
+
+function getEntityDescription( entity, count ) {
+	switch ( entity ) {
+		case 'site':
+			return 1 === count
+				? __( 'This change will affect your whole site.' )
+				: __( 'These changes will affect your whole site.' );
+		case 'wp_template':
+			return __(
+				'This change will affect other parts of your site that use this template.'
+			);
+		case 'page':
+		case 'post':
+			return __( 'The following has been modified.' );
+	}
+}
+
+function GlobalStylesDescription( { record } ) {
+	const { editedRecord, savedRecord } = useSelect(
+		( select ) => {
+			const { getEditedEntityRecord, getEntityRecord } =
+				select( STORE_NAME );
+			return {
+				editedRecord: getEditedEntityRecord(
+					record.kind,
+					record.name,
+					record.key
+				),
+				savedRecord: getEntityRecord(
+					record.kind,
+					record.name,
+					record.key
+				),
+			};
+		},
+		[ record.kind, record.name, record.key ]
+	);
+
+	const globalStylesChanges = getGlobalStylesChanges(
+		editedRecord,
+		savedRecord,
+		{
+			maxResults: 10,
+		}
+	);
+	return globalStylesChanges.length ? (
+		<ul className="entities-saved-states__changes">
+			{ globalStylesChanges.map( ( change ) => (
+				<li key={ change }>{ change }</li>
+			) ) }
+		</ul>
+	) : null;
+}
+
+function EntityDescription( { record, count } ) {
+	if ( 'globalStyles' === record?.name ) {
+		return null;
+	}
+	const description = getEntityDescription( record?.name, count );
+	return description ? <PanelRow>{ description }</PanelRow> : null;
+}
+
+export default function EntityTypeList( {
+	list,
+	unselectedEntities,
+	setUnselectedEntities,
+} ) {
+	const count = list.length;
+	const firstRecord = list[ 0 ];
+	const entityConfig = useSelect(
+		( select ) =>
+			select( STORE_NAME ).getEntityConfig(
+				firstRecord.kind,
+				firstRecord.name
+			),
+		[ firstRecord.kind, firstRecord.name ]
+	);
+
+	let entityLabel = entityConfig.label;
+	if ( firstRecord?.name === 'wp_template_part' ) {
+		entityLabel =
+			1 === count ? __( 'Template Part' ) : __( 'Template Parts' );
+	}
+
+	return (
+		<PanelBody
+			title={ entityLabel }
+			initialOpen
+			className="entities-saved-states__panel-body"
+		>
+			<EntityDescription record={ firstRecord } count={ count } />
+			{ list.map( ( record ) => {
+				return (
+					<EntityRecordItem
+						key={ record.key || record.property }
+						record={ record }
+						checked={
+							! unselectedEntities.some(
+								( elt ) =>
+									elt.kind === record.kind &&
+									elt.name === record.name &&
+									elt.key === record.key &&
+									elt.property === record.property
+							)
+						}
+						onChange={ ( value ) =>
+							setUnselectedEntities( record, value )
+						}
+					/>
+				);
+			} ) }
+			{ 'globalStyles' === firstRecord?.name && (
+				<GlobalStylesDescription record={ firstRecord } />
+			) }
+		</PanelBody>
+	);
+}

package/src/components/entities-saved-states/hooks/use-is-dirty.js

@@ -0,0 +1,101 @@
+/**
+ * WordPress dependencies
+ */
+import { useSelect } from '@wordpress/data';
+import { useMemo, useState } from '@wordpress/element';
+
+/**
+ * Internal dependencies
+ */
+import { STORE_NAME } from '../../../name';
+
+/**
+ * Custom hook that determines if any entities are dirty (edited) and provides a way to manage selected/unselected entities.
+ *
+ * @return {Object} An object containing the following properties:
+ *   - dirtyEntityRecords: An array of dirty entity records.
+ *   - isDirty: A boolean indicating if there are any dirty entity records.
+ *   - setUnselectedEntities: A function to set the unselected entities.
+ *   - unselectedEntities: An array of unselected entities.
+ */
+export const useIsDirty = () => {
+	const { editedEntities, siteEdits, siteEntityConfig } = useSelect(
+		( select ) => {
+			const {
+				__experimentalGetDirtyEntityRecords,
+				getEntityRecordEdits,
+				getEntityConfig,
+			} = select( STORE_NAME );
+
+			return {
+				editedEntities: __experimentalGetDirtyEntityRecords(),
+				siteEdits: getEntityRecordEdits( 'root', 'site' ),
+				siteEntityConfig: getEntityConfig( 'root', 'site' ),
+			};
+		},
+		[]
+	);
+
+	const dirtyEntityRecords = useMemo( () => {
+		// Remove site object and decouple into its edited pieces.
+		const editedEntitiesWithoutSite = editedEntities.filter(
+			( record ) => ! ( record.kind === 'root' && record.name === 'site' )
+		);
+
+		const siteEntityLabels = siteEntityConfig?.meta?.labels ?? {};
+		const {
+			site_logo: siteLogoEdit,
+			site_icon: siteIconEdit,
+			...otherSiteEdits
+		} = siteEdits ?? {};
+		const orderedSiteProperties = [
+			siteLogoEdit !== undefined && 'site_logo',
+			siteIconEdit !== undefined && 'site_icon',
+			...Object.keys( otherSiteEdits ),
+		].filter( Boolean );
+		const editedSiteEntities = orderedSiteProperties.map(
+			( property ) => ( {
+				kind: 'root',
+				name: 'site',
+				title: siteEntityLabels[ property ] || property,
+				property,
+			} )
+		);
+
+		return [ ...editedEntitiesWithoutSite, ...editedSiteEntities ];
+	}, [ editedEntities, siteEdits, siteEntityConfig ] );
+
+	// Unchecked entities to be ignored by save function.
+	const [ unselectedEntities, _setUnselectedEntities ] = useState( [] );
+
+	const setUnselectedEntities = (
+		{ kind, name, key, property },
+		checked
+	) => {
+		if ( checked ) {
+			_setUnselectedEntities(
+				unselectedEntities.filter(
+					( elt ) =>
+						elt.kind !== kind ||
+						elt.name !== name ||
+						elt.key !== key ||
+						elt.property !== property
+				)
+			);
+		} else {
+			_setUnselectedEntities( [
+				...unselectedEntities,
+				{ kind, name, key, property },
+			] );
+		}
+	};
+
+	const isDirty = dirtyEntityRecords.length - unselectedEntities.length > 0;
+
+	return {
+		dirtyEntityRecords,
+		isDirty,
+		setUnselectedEntities,
+		unselectedEntities,
+	};
+};