@wordpress/core-data 6.16.0 → 6.17.1

package/build-types/entities.d.ts

@@ -8,6 +8,13 @@ export const rootEntitiesConfig: ({
         _fields: string;
         context?: undefined;
     };
+    syncConfig: {
+        fetch: () => Promise<any>;
+        applyChangesToDoc: (doc: any, changes: any) => void;
+        fromCRDTDoc: (doc: any) => any;
+    };
+    syncObjectType: string;
+    getSyncObjectId: () => string;
     getTitle?: undefined;
     key?: undefined;
     plural?: undefined;
@@ -19,6 +26,13 @@ export const rootEntitiesConfig: ({
     kind: string;
     baseURL: string;
     getTitle: (record: any) => any;
+    syncConfig: {
+        fetch: () => Promise<any>;
+        applyChangesToDoc: (doc: any, changes: any) => void;
+        fromCRDTDoc: (doc: any) => any;
+    };
+    syncObjectType: string;
+    getSyncObjectId: () => string;
     baseURLParams?: undefined;
     key?: undefined;
     plural?: undefined;
@@ -34,6 +48,13 @@ export const rootEntitiesConfig: ({
         context: string;
         _fields?: undefined;
     };
+    syncConfig: {
+        fetch: (id: any) => Promise<any>;
+        applyChangesToDoc: (doc: any, changes: any) => void;
+        fromCRDTDoc: (doc: any) => any;
+    };
+    syncObjectType: string;
+    getSyncObjectId: (id: any) => any;
     getTitle?: undefined;
     plural?: undefined;
     rawAttributes?: undefined;
@@ -49,6 +70,9 @@ export const rootEntitiesConfig: ({
     plural: string;
     label: string;
     rawAttributes: string[];
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
     getTitle?: undefined;
     key?: undefined;
     transientEdits?: undefined;
@@ -63,6 +87,9 @@ export const rootEntitiesConfig: ({
     };
     plural: string;
     label: string;
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
     getTitle?: undefined;
     rawAttributes?: undefined;
     transientEdits?: undefined;
@@ -79,6 +106,9 @@ export const rootEntitiesConfig: ({
         blocks: boolean;
     };
     label: string;
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
     getTitle?: undefined;
     key?: undefined;
     rawAttributes?: undefined;
@@ -92,6 +122,9 @@ export const rootEntitiesConfig: ({
     };
     plural: string;
     label: string;
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
     getTitle?: undefined;
     key?: undefined;
     rawAttributes?: undefined;
@@ -107,9 +140,29 @@ export const rootEntitiesConfig: ({
     };
     plural: string;
     getTitle: (record: any) => any;
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
     key?: undefined;
     rawAttributes?: undefined;
     transientEdits?: undefined;
+} | {
+    label: string;
+    name: string;
+    kind: string;
+    baseURL: string;
+    baseURLParams: {
+        context: string;
+        _fields?: undefined;
+    };
+    key: string;
+    syncConfig?: undefined;
+    syncObjectType?: undefined;
+    getSyncObjectId?: undefined;
+    getTitle?: undefined;
+    plural?: undefined;
+    rawAttributes?: undefined;
+    transientEdits?: undefined;
 })[];
 export const additionalEntityConfigLoaders: {
     kind: string;

package/build-types/entities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../src/entities.js"],"names":[],"mappings":"AAgBA,sCAAuC;AAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoJE;AAEF;;;IAGE;AASK,0EAqBN;AAgFM,oCAPI,MAAM,QACN,MAAM,WACN,MAAM,cACN,OAAO,GAEN,MAAM,CAkBjB;AASM,8CAJI,MAAM,eAEO,MAAM,KAAK,cAAc,CAqB/C;AA1HF;;;;GAIG;AACH,sDA+BC"}
+{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../src/entities.js"],"names":[],"mappings":"AAiBA,sCAAuC;AAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4ME;AAEF;;;IAGE;AASK,0EAqBN;AAuGM,oCAPI,MAAM,QACN,MAAM,WACN,MAAM,cACN,OAAO,GAEN,MAAM,CAkBjB;AAkBM,8CAJI,MAAM,eAEO,MAAM,KAAK,cAAc,CAuB/C;AA5JF;;;;GAIG;AACH,sDAsDC"}

package/build-types/entity-provider.d.ts

@@ -50,7 +50,7 @@ export function useEntityProp(kind: string, name: string, prop: string, _id?: st
  * The return value has the shape `[ blocks, onInput, onChange ]`.
  * `onInput` is for block changes that don't create undo levels
  * or dirty the post, non-persistent changes, and `onChange` is for
- * peristent changes. They map directly to the props of a
+ * persistent changes. They map directly to the props of a
  * `BlockEditorProvider` and are intended to be used with it,
  * or similar components or hooks.
  *

package/build-types/entity-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-provider.d.ts","sourceRoot":"","sources":["../src/entity-provider.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;GAYG;AACH;IARyB,IAAI,EAAlB,MAAM;IACQ,IAAI,EAAlB,MAAM;IACQ,EAAE,EAAhB,MAAM;IACQ,QAAQ;QAQhC;AAED;;;;;;GAMG;AACH,kCAHW,MAAM,QACN,MAAM,OAIhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,oCAZW,MAAM,QACN,MAAM,QACN,MAAM,6BAGL,oBAAgB,CAqC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAPW,MAAM,QACN,MAAM;IAEW,EAAE;IAElB,CAAC,OAAO,EAAE,qBAAqB,CAsM1C"}
+{"version":3,"file":"entity-provider.d.ts","sourceRoot":"","sources":["../src/entity-provider.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;GAYG;AACH;IARyB,IAAI,EAAlB,MAAM;IACQ,IAAI,EAAlB,MAAM;IACQ,EAAE,EAAhB,MAAM;IACQ,QAAQ;QAQhC;AAED;;;;;;GAMG;AACH,kCAHW,MAAM,QACN,MAAM,OAIhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,oCAZW,MAAM,QACN,MAAM,QACN,MAAM,6BAGL,oBAAgB,CAqC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAPW,MAAM,QACN,MAAM;IAEW,EAAE;IAElB,CAAC,OAAO,EAAE,qBAAqB,CA+M1C"}

package/build-types/hooks/memoize.d.ts

@@ -1,3 +1,3 @@
 export default memoize;
-import memoize from "memize";
+import memoize from 'memize';
 //# sourceMappingURL=memoize.d.ts.map

package/build-types/hooks/memoize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/hooks/memoize.js"],"names":[],"mappings":""}
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/hooks/memoize.js"],"names":[],"mappings":";oBAGoB,QAAQ"}

package/build-types/index.d.ts

@@ -63,7 +63,7 @@ export const store: import("@wordpress/data/build-types/types").StoreDescriptor<
 }, {
     getAuthors(state: selectors.State, query?: {
         [x: string]: any;
-    } | undefined): import("./entity-types").User<"edit">[];
+    } | undefined): import("./entity-types").User[];
     getCurrentUser(state: selectors.State): import("./entity-types").User<"edit">;
     getEntitiesByKind(state: selectors.State, kind: string): any[];
     getEntitiesConfig(state: selectors.State, kind: string): any[];
@@ -93,7 +93,7 @@ export const store: import("@wordpress/data/build-types/types").StoreDescriptor<
     canUserEditEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean | undefined;
     getAutosaves(state: selectors.State, postType: string, postId: string | number): any[] | undefined;
     getAutosave<EntityRecord_1 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>(state: selectors.State, postType: string, postId: string | number, authorId: string | number): EntityRecord_1 | undefined;
-    __experimentalGetTemplateForLink(state: selectors.State, link: string): (import("./entity-types").Updatable<import("./entity-types").WpTemplate<"edit">> | undefined) | null;
+    __experimentalGetTemplateForLink(state: selectors.State, link: string): (import("./entity-types").Updatable<import("./entity-types").WpTemplate> | undefined) | null;
     __experimentalGetCurrentThemeBaseGlobalStyles(state: selectors.State): any;
     __experimentalGetCurrentThemeGlobalStylesVariations(state: selectors.State): string | null;
     getBlockPatterns(state: selectors.State): any[];
@@ -126,5 +126,5 @@ export * from "./entity-provider";
 export * from "./entity-types";
 export * from "./fetch";
 export * from "./hooks";
-import * as selectors from "./selectors";
+import * as selectors from './selectors';
 //# sourceMappingURL=index.d.ts.map

package/build-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA4DA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA4DA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmE;;;;;;2BAxDxC,aAAa"}

package/build-types/resolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../src/resolvers.js"],"names":[],"mappings":"AAwBO,kCAHI,MAAO,SAAS;;oBAYzB;AAKK;;oBAKL;AAYK,sCAPI,MAAM,QACN,MAAM,2CAEN,MAAO,SAAS;;;oBAsEzB;AAEF;;GAEG;AACH,0CAAuE;AAEvE;;GAEG;AACH,6CAA0E;AAUnE,uCALI,MAAM,QACN,MAAM;;oBAoFf;;IAEF,kEAOC;;AAKM;;;oBAUL;AAEF;;GAEG;AACH,wCAAqE;AAO9D,qCAFI,MAAM;;oBAcf;AAWK,yCALI,MAAM,YAEN,MAAM,MACL,MAAM;;;oBAiEhB;AAUK,8CAJI,MAAM,QACN,MAAM,YACN,MAAM;;oBAef;AAQK,uCAHI,MAAM,UACN,MAAM;;;oBAcf;AAWK,sCAHI,MAAM,UACN,MAAM;;oBAMf;AAOK,uDAFI,MAAM;;;oBAsCf;;IAEF,4CAOC;;AAEM;;;oBAmBL;AAEK;;;oBAWL;AAEK;;;oBAWL;AAKK;;;oBA+BL;;IAEF,gDAOC;;AAEM;;oBAeL;AAEK;;oBAOL;AAEK;;;oBAsCL"}
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../src/resolvers.js"],"names":[],"mappings":"AAyBO,kCAHI,MAAO,SAAS;;oBAYzB;AAKK;;oBAKL;AAYK,sCAPI,MAAM,QACN,MAAM,2CAEN,MAAO,SAAS;;;oBAqHzB;AAEF;;GAEG;AACH,0CAAuE;AAEvE;;GAEG;AACH,6CAA0E;AAUnE,uCALI,MAAM,QACN,MAAM;;oBAoFf;;IAEF,kEAOC;;AAKM;;;oBAUL;AAEF;;GAEG;AACH,wCAAqE;AAO9D,qCAFI,MAAM;;oBAcf;AAWK,yCALI,MAAM,YAEN,MAAM,MACL,MAAM;;;oBAiEhB;AAUK,8CAJI,MAAM,QACN,MAAM,YACN,MAAM;;oBAef;AAQK,uCAHI,MAAM,UACN,MAAM;;;oBAcf;AAWK,sCAHI,MAAM,UACN,MAAM;;oBAMf;AAOK,uDAFI,MAAM;;;oBAsCf;;IAEF,4CAOC;;AAEM;;;oBAmBL;AAEK;;;oBAWL;AAEK;;;oBAWL;AAKK;;;oBA+BL;;IAEF,gDAOC;;AAEM;;oBAeL;AAEK;;oBAOL;AAEK;;;oBAsCL"}

package/build-types/sync.d.ts

@@ -0,0 +1,2 @@
+export function getSyncProvider(): any;
+//# sourceMappingURL=sync.d.ts.map

package/build-types/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.js"],"names":[],"mappings":"AAWA,uCAMC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/core-data",
-	"version": "6.16.0",
+	"version": "6.17.1",
 	"description": "Access to and manipulation of core WordPress entities.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -31,18 +31,19 @@
 	],
 	"dependencies": {
 		"@babel/runtime": "^7.16.0",
-		"@wordpress/api-fetch": "^6.36.0",
-		"@wordpress/block-editor": "^12.7.0",
-		"@wordpress/blocks": "^12.16.0",
-		"@wordpress/compose": "^6.16.0",
-		"@wordpress/data": "^9.9.0",
-		"@wordpress/deprecated": "^3.39.0",
-		"@wordpress/element": "^5.16.0",
-		"@wordpress/html-entities": "^3.39.0",
-		"@wordpress/i18n": "^4.39.0",
-		"@wordpress/is-shallow-equal": "^4.39.0",
-		"@wordpress/private-apis": "^0.21.0",
-		"@wordpress/url": "^3.40.0",
+		"@wordpress/api-fetch": "^6.37.1",
+		"@wordpress/block-editor": "^12.8.1",
+		"@wordpress/blocks": "^12.17.1",
+		"@wordpress/compose": "^6.17.1",
+		"@wordpress/data": "^9.10.1",
+		"@wordpress/deprecated": "^3.40.1",
+		"@wordpress/element": "^5.17.1",
+		"@wordpress/html-entities": "^3.40.1",
+		"@wordpress/i18n": "^4.40.1",
+		"@wordpress/is-shallow-equal": "^4.40.1",
+		"@wordpress/private-apis": "^0.22.1",
+		"@wordpress/sync": "^0.2.1",
+		"@wordpress/url": "^3.41.1",
 		"change-case": "^4.1.2",
 		"equivalent-key-map": "^0.2.2",
 		"fast-deep-equal": "^3.1.3",
@@ -51,10 +52,11 @@
 		"uuid": "^8.3.0"
 	},
 	"peerDependencies": {
-		"react": "^18.0.0"
+		"react": "^18.0.0",
+		"react-dom": "^18.0.0"
 	},
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "b898cf1dc8e70841d1647ea0994ac6278acc18a7"
+	"gitHead": "bb1fbf87bb0f451744530fc6a85de2dff1263bed"
 }

package/src/actions.js

@@ -18,6 +18,7 @@ import { receiveItems, removeItems, receiveQueriedItems } from './queried-data';
 import { getOrLoadEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 import { createBatch } from './batch';
 import { STORE_NAME } from './name';
+import { getSyncProvider } from './sync';
 
 /**
  * Returns an action object used in signalling that authors have been received.
@@ -382,21 +383,30 @@ export const editEntityRecord =
 				return acc;
 			}, {} ),
 		};
-		dispatch( {
-			type: 'EDIT_ENTITY_RECORD',
-			...edit,
-			meta: {
-				undo: ! options.undoIgnore && {
-					...edit,
-					// Send the current values for things like the first undo stack entry.
-					edits: Object.keys( edits ).reduce( ( acc, key ) => {
-						acc[ key ] = editedRecord[ key ];
-						return acc;
-					}, {} ),
-					isCached: options.isCached,
+		if ( window.__experimentalEnableSync && entityConfig.syncConfig ) {
+			const objectId = entityConfig.getSyncObjectId( recordId );
+			getSyncProvider().update(
+				entityConfig.syncObjectType + '--edit',
+				objectId,
+				edit.edits
+			);
+		} else {
+			dispatch( {
+				type: 'EDIT_ENTITY_RECORD',
+				...edit,
+				meta: {
+					undo: ! options.undoIgnore && {
+						...edit,
+						// Send the current values for things like the first undo stack entry.
+						edits: Object.keys( edits ).reduce( ( acc, key ) => {
+							acc[ key ] = editedRecord[ key ];
+							return acc;
+						}, {} ),
+						isCached: options.isCached,
+					},
 				},
-			},
-		} );
+			} );
+		}
 	};
 
 /**

package/src/entities.js

@@ -13,6 +13,7 @@ import { __ } from '@wordpress/i18n';
  * Internal dependencies
  */
 import { addEntities } from './actions';
+import { getSyncProvider } from './sync';
 
 export const DEFAULT_ENTITY_KEY = 'id';
 
@@ -37,6 +38,24 @@ export const rootEntitiesConfig = [
 				'url',
 			].join( ',' ),
 		},
+		syncConfig: {
+			fetch: async () => {
+				return apiFetch( { path: '/' } );
+			},
+			applyChangesToDoc: ( doc, changes ) => {
+				const document = doc.getMap( 'document' );
+				Object.entries( changes ).forEach( ( [ key, value ] ) => {
+					if ( document.get( key ) !== value ) {
+						document.set( key, value );
+					}
+				} );
+			},
+			fromCRDTDoc: ( doc ) => {
+				return doc.getMap( 'document' ).toJSON();
+			},
+		},
+		syncObjectType: 'root/base',
+		getSyncObjectId: () => 'index',
 	},
 	{
 		label: __( 'Site' ),
@@ -46,6 +65,24 @@ export const rootEntitiesConfig = [
 		getTitle: ( record ) => {
 			return record?.title ?? __( 'Site Title' );
 		},
+		syncConfig: {
+			fetch: async () => {
+				return apiFetch( { path: '/wp/v2/settings' } );
+			},
+			applyChangesToDoc: ( doc, changes ) => {
+				const document = doc.getMap( 'document' );
+				Object.entries( changes ).forEach( ( [ key, value ] ) => {
+					if ( document.get( key ) !== value ) {
+						document.set( key, value );
+					}
+				} );
+			},
+			fromCRDTDoc: ( doc ) => {
+				return doc.getMap( 'document' ).toJSON();
+			},
+		},
+		syncObjectType: 'root/site',
+		getSyncObjectId: () => 'index',
 	},
 	{
 		label: __( 'Post Type' ),
@@ -54,6 +91,26 @@ export const rootEntitiesConfig = [
 		key: 'slug',
 		baseURL: '/wp/v2/types',
 		baseURLParams: { context: 'edit' },
+		syncConfig: {
+			fetch: async ( id ) => {
+				return apiFetch( {
+					path: `/wp/v2/types/${ id }?context=edit`,
+				} );
+			},
+			applyChangesToDoc: ( doc, changes ) => {
+				const document = doc.getMap( 'document' );
+				Object.entries( changes ).forEach( ( [ key, value ] ) => {
+					if ( document.get( key ) !== value ) {
+						document.set( key, value );
+					}
+				} );
+			},
+			fromCRDTDoc: ( doc ) => {
+				return doc.getMap( 'document' ).toJSON();
+			},
+		},
+		syncObjectType: 'root/postType',
+		getSyncObjectId: ( id ) => id,
 	},
 	{
 		name: 'media',
@@ -237,6 +294,29 @@ async function loadPostTypeEntities() {
 					: String( record.id ) ),
 			__unstablePrePersist: isTemplate ? undefined : prePersistPostType,
 			__unstable_rest_base: postType.rest_base,
+			syncConfig: {
+				fetch: async ( id ) => {
+					return apiFetch( {
+						path: `/${ namespace }/${ postType.rest_base }/${ id }?context=edit`,
+					} );
+				},
+				applyChangesToDoc: ( doc, changes ) => {
+					const document = doc.getMap( 'document' );
+					Object.entries( changes ).forEach( ( [ key, value ] ) => {
+						if (
+							document.get( key ) !== value &&
+							typeof value !== 'function'
+						) {
+							document.set( key, value );
+						}
+					} );
+				},
+				fromCRDTDoc: ( doc ) => {
+					return doc.getMap( 'document' ).toJSON();
+				},
+			},
+			syncObjectType: 'postType/' + postType.name,
+			getSyncObjectId: ( id ) => id,
 		};
 	} );
 }
@@ -299,6 +379,15 @@ export const getMethodName = (
 	return `${ prefix }${ kindPrefix }${ suffix }`;
 };
 
+function registerSyncConfigs( configs ) {
+	configs.forEach( ( { syncObjectType, syncConfig } ) => {
+		getSyncProvider().register( syncObjectType, syncConfig );
+		const editSyncConfig = { ...syncConfig };
+		delete editSyncConfig.fetch;
+		getSyncProvider().register( syncObjectType + '--edit', editSyncConfig );
+	} );
+}
+
 /**
  * Loads the kind entities into the store.
  *
@@ -311,6 +400,7 @@ export const getOrLoadEntitiesConfig =
 	async ( { select, dispatch } ) => {
 		let configs = select.getEntitiesConfig( kind );
 		if ( configs && configs.length !== 0 ) {
+			registerSyncConfigs( configs );
 			return configs;
 		}
 
@@ -322,6 +412,7 @@ export const getOrLoadEntitiesConfig =
 		}
 
 		configs = await loader.loadEntities();
+		registerSyncConfigs( configs );
 		dispatch( addEntities( configs ) );
 
 		return configs;

package/src/entity-provider.js

@@ -142,7 +142,7 @@ export function useEntityProp( kind, name, prop, _id ) {
  * The return value has the shape `[ blocks, onInput, onChange ]`.
  * `onInput` is for block changes that don't create undo levels
  * or dirty the post, non-persistent changes, and `onChange` is for
- * peristent changes. They map directly to the props of a
+ * persistent changes. They map directly to the props of a
  * `BlockEditorProvider` and are intended to be used with it,
  * or similar components or hooks.
  *
@@ -221,6 +221,15 @@ export function useEntityBlockEditor( kind, name, { id: _id } = {} ) {
 			);
 
 			function updateAttributes( attributes ) {
+				// Only attempt to update attributes, if attributes is an object.
+				if (
+					! attributes ||
+					Array.isArray( attributes ) ||
+					typeof attributes !== 'object'
+				) {
+					return attributes;
+				}
+
 				attributes = { ...attributes };
 
 				for ( const key in attributes ) {
@@ -281,7 +290,7 @@ export function useEntityBlockEditor( kind, name, { id: _id } = {} ) {
 				} );
 			}
 
-			// We need to go through all block attributs deeply and update the
+			// We need to go through all block attributes deeply and update the
 			// footnote anchor numbering (textContent) to match the new order.
 			const newBlocks = updateBlocksAttributes( _blocks );
 

package/src/resolvers.js

@@ -15,6 +15,7 @@ import apiFetch from '@wordpress/api-fetch';
 import { STORE_NAME } from './name';
 import { getOrLoadEntitiesConfig, DEFAULT_ENTITY_KEY } from './entities';
 import { forwardResolver, getNormalizedCommaSeparable } from './utils';
+import { getSyncProvider } from './sync';
 
 /**
  * Requests authors from the REST API.
@@ -71,51 +72,98 @@ export const getEntityRecord =
 		);
 
 		try {
-			if ( query !== undefined && query._fields ) {
-				// If requesting specific fields, items and query association to said
-				// records are stored by ID reference. Thus, fields must always include
-				// the ID.
-				query = {
-					...query,
-					_fields: [
-						...new Set( [
-							...( getNormalizedCommaSeparable( query._fields ) ||
-								[] ),
-							entityConfig.key || DEFAULT_ENTITY_KEY,
-						] ),
-					].join(),
-				};
-			}
-
-			// Disable reason: While true that an early return could leave `path`
-			// unused, it's important that path is derived using the query prior to
-			// additional query modifications in the condition below, since those
-			// modifications are relevant to how the data is tracked in state, and not
-			// for how the request is made to the REST API.
-
-			// eslint-disable-next-line @wordpress/no-unused-vars-before-return
-			const path = addQueryArgs(
-				entityConfig.baseURL + ( key ? '/' + key : '' ),
-				{
-					...entityConfig.baseURLParams,
-					...query,
+			// Entity supports configs,
+			// use the sync algorithm instead of the old fetch behavior.
+			if (
+				window.__experimentalEnableSync &&
+				entityConfig.syncConfig &&
+				! query
+			) {
+				const objectId = entityConfig.getSyncObjectId( key );
+
+				// Loads the persisted document.
+				await getSyncProvider().bootstrap(
+					entityConfig.syncObjectType,
+					objectId,
+					( record ) => {
+						dispatch.receiveEntityRecords(
+							kind,
+							name,
+							record,
+							query
+						);
+					}
+				);
+
+				// Boostraps the edited document as well (and load from peers).
+				await getSyncProvider().bootstrap(
+					entityConfig.syncObjectType + '--edit',
+					objectId,
+					( record ) => {
+						dispatch( {
+							type: 'EDIT_ENTITY_RECORD',
+							kind,
+							name,
+							recordId: key,
+							edits: record,
+							meta: {
+								undo: undefined,
+							},
+						} );
+					}
+				);
+			} else {
+				if ( query !== undefined && query._fields ) {
+					// If requesting specific fields, items and query association to said
+					// records are stored by ID reference. Thus, fields must always include
+					// the ID.
+					query = {
+						...query,
+						_fields: [
+							...new Set( [
+								...( getNormalizedCommaSeparable(
+									query._fields
+								) || [] ),
+								entityConfig.key || DEFAULT_ENTITY_KEY,
+							] ),
+						].join(),
+					};
 				}
-			);
-
-			if ( query !== undefined ) {
-				query = { ...query, include: [ key ] };
 
-				// The resolution cache won't consider query as reusable based on the
-				// fields, so it's tested here, prior to initiating the REST request,
-				// and without causing `getEntityRecords` resolution to occur.
-				const hasRecords = select.hasEntityRecords( kind, name, query );
-				if ( hasRecords ) {
-					return;
+				// Disable reason: While true that an early return could leave `path`
+				// unused, it's important that path is derived using the query prior to
+				// additional query modifications in the condition below, since those
+				// modifications are relevant to how the data is tracked in state, and not
+				// for how the request is made to the REST API.
+
+				// eslint-disable-next-line @wordpress/no-unused-vars-before-return
+				const path = addQueryArgs(
+					entityConfig.baseURL + ( key ? '/' + key : '' ),
+					{
+						...entityConfig.baseURLParams,
+						...query,
+					}
+				);
+
+				if ( query !== undefined ) {
+					query = { ...query, include: [ key ] };
+
+					// The resolution cache won't consider query as reusable based on the
+					// fields, so it's tested here, prior to initiating the REST request,
+					// and without causing `getEntityRecords` resolution to occur.
+					const hasRecords = select.hasEntityRecords(
+						kind,
+						name,
+						query
+					);
+					if ( hasRecords ) {
+						return;
+					}
 				}
-			}
 
-			const record = await apiFetch( { path } );
-			dispatch.receiveEntityRecords( kind, name, record, query );
+				const record = await apiFetch( { path } );
+				dispatch.receiveEntityRecords( kind, name, record, query );
+			}
 		} finally {
 			dispatch.__unstableReleaseStoreLock( lock );
 		}

package/src/sync.js

@@ -0,0 +1,18 @@
+/**
+ * WordPress dependencies
+ */
+import {
+	createSyncProvider,
+	connectIndexDb,
+	connectWebRTC,
+} from '@wordpress/sync';
+
+let syncProvider;
+
+export function getSyncProvider() {
+	if ( ! syncProvider ) {
+		syncProvider = createSyncProvider( connectIndexDb, connectWebRTC );
+	}
+
+	return syncProvider;
+}