@plaudit/gutenberg-api-extensions 2.90.1 → 2.91.1

package/src/blocks/common-native-property-constructors.tsx

@@ -449,13 +449,10 @@ function hydrateDesiccatedSimpleNativeProperty(
 				}
 			};
 		case "select":
-			registerPlainTextLabelRequiredMarker("select", " > .components-form-token-field .components-form-token-field__label");
 			return hydrateSelectProperty(config);
 		case "taxonomy":
-			registerPlainTextLabelRequiredMarker("taxonomy", " > .components-form-token-field .components-form-token-field__label");
 			return hydrateTaxonomyProperty(config);
 		case "term":
-			registerPlainTextLabelRequiredMarker("term", " > .components-form-token-field .components-form-token-field__label");
 			return hydrateTermProperty(config);
 		case "textarea":
 			return {
@@ -592,7 +589,7 @@ function NumberLikeListTextControl({listComponent, datum, itemType, onDatumChang
 type PotentiallyExtendedRadioControlProps = CSNPControlComponentProps<RadioPropertyCSNPConfig, string>&SNPControlSlots;
 function PotentiallyExtendedRadioControl({config, value, onChange, Label, Messages}: PotentiallyExtendedRadioControlProps) {
 	const unsuspendedOptions = useSuspendableOptions(config);
-	const options = useAsOptions(unsuspendedOptions, value);
+	const options = useAsOptions(unsuspendedOptions, value, undefined);
 
 	if (config.allowCustom) {
 		return <ExtendedRadioControl {...config.component} selected={value} onChange={onChange} options={options} label={config.label} help={config.help}
@@ -714,6 +711,7 @@ export function hydrateUserProperty(config: UserPropertyCSNPConfig): HydratedSim
 }
 
 export function hydrateTaxonomyProperty(config: TaxonomyPropertyCSNPConfig): HydratedSimpleNativeProperty {
+	registerPlainTextLabelRequiredMarker("taxonomy", " > .components-form-token-field .components-form-token-field__label");
 	if (config.multiple === false) {
 		return {
 			name: config.name,
@@ -766,6 +764,7 @@ export function hydrateTaxonomyProperty(config: TaxonomyPropertyCSNPConfig): Hyd
 }
 
 export function hydrateTermProperty(config: TermPropertyCSNPConfig): HydratedSimpleNativeProperty {
+	registerPlainTextLabelRequiredMarker("term", " > .components-form-token-field .components-form-token-field__label");
 	if (config.multiple === false) {
 		return {
 			name: config.name,
@@ -818,6 +817,7 @@ export function hydrateTermProperty(config: TermPropertyCSNPConfig): HydratedSim
 }
 
 function hydrateSelectProperty(config: SelectPropertyCSNPConfig): HydratedSimpleNativeProperty {
+	registerPlainTextLabelRequiredMarker("select", " > .components-form-token-field .components-form-token-field__label");
 	if (config.multiple) {
 		return {
 			name: config.name,
@@ -849,11 +849,12 @@ function hydrateSelectProperty(config: SelectPropertyCSNPConfig): HydratedSimple
 			transformer: config.transformer,
 			controlType: 'select',
 			control({value, onChange, slots: {Label, Messages}}) {
-				const normalizedOptions = useAsOptions(useSuspendableOptions(config), value, config.clearable ? '' : undefined);
+				const currentValue = value ?? config.default;
+				const normalizedOptions = useAsOptions(useSuspendableOptions(config), currentValue, config.clearable ? '' : undefined);
 				return <>
 					<SelectControl
+						value={currentValue ?? ''} onChange={onChange} options={normalizedOptions} label={<Label />} help={config.help}
 						__nextHasNoMarginBottom __next40pxDefaultSize
-						value={value ?? config.default ?? ''} onChange={onChange} options={normalizedOptions} label={<Label />} help={config.help}
 					/>
 					<Messages />
 				</>;
@@ -862,14 +863,19 @@ function hydrateSelectProperty(config: SelectPropertyCSNPConfig): HydratedSimple
 	}
 }
 
-function useAsOptions<T extends string|number>(options: PickableOptions<T>, currentValue: T|undefined|null, noSelectionValue?: T) {
+function useAsOptions<T extends string>(options: PickableOptions<T>, currentValue: T|undefined|null, noSelectionValue: T|undefined) {
 	const normalizedOptions = useMemo(() => asOptions(options, noSelectionValue), [options, noSelectionValue]);
 	return useMemo(() => {
-		if ((currentValue !== undefined && currentValue !== null) && !normalizedOptions.find(opt => opt.value === currentValue)) {
-			if (noSelectionValue !== undefined && !normalizedOptions.some(opt => !opt.value)) {
-				return [normalizedOptions[0]!, {value: currentValue, label: currentValue.toString(), disabled: true}, ...normalizedOptions.slice(1)];
-			} else {
-				return [{value: currentValue, label: currentValue.toString(), disabled: true}, ...normalizedOptions];
+		if (!normalizedOptions.find(opt => opt.value === currentValue)) {
+			if (currentValue !== undefined && currentValue !== null) {
+				const defaultValueItem = {value: currentValue, label: currentValue === "" ? "-- Default --" : currentValue.toString(), disabled: true};
+				if (noSelectionValue !== undefined && !normalizedOptions.some(opt => !opt.value)) {
+					return normalizedOptions.toSpliced(1, 0, defaultValueItem);
+				} else {
+					return [defaultValueItem, ...normalizedOptions];
+				}
+			} else if (noSelectionValue === undefined) {
+				return [{value: "", label: "-- Default --", disabled: true}, ...normalizedOptions];
 			}
 		}
 		return normalizedOptions;

package/src/blocks/data-controller/reducer.ts

@@ -30,10 +30,7 @@ export function buildReducer(blockClientId: string) {
 				}
 				for (const property of properties) {
 					for (const prop of Array.isArray(property) ? property : [property]) {
-						if (dataStore.getValue(prop.name) === undefined && meta.inBatch) {
-							state.batchAddedPropertiesThatNeedWriteThrough.push(recordCloneableDefaultValueForNode(prop));
-						}
-						dataStore.addProperty(prop, !meta.inBatch);
+						dataStore.addProperty(prop);
 						state.dataStores.byProperty[prop.name] = dataStore;
 						state.treeRoot.children[prop.name] = buildNodeFromDataAndDefinition(dataStore.getValue(prop.name), prop);
 					}

package/src/blocks/data-controller/trigger-handlers.ts

@@ -15,7 +15,8 @@ import {
 	TreeMutatorResult,
 	walkToNode,
 	walkToNodeInValue,
-	writeValueToBackingDataStore
+	writeValueToBackingDataStore,
+	writeValueToBackingDataStoreWithCorrections,
 } from "./utils";
 
 type BasePayload = {[key in string]: any}&{type?: never, inBatch?: never};
@@ -107,21 +108,19 @@ function performConditionChecks(state: Draft<DCStoreState>) {
 	applyToTree(state.treeRoot, (node, path) => {
 		const condition = node.condition;
 		if (condition === undefined) {
+			if (node.rendered === undefined) {
+				if (getDataStoreAndCurrentValue(path, state).currentValue === undefined) {
+					// Restore from backup if we are transitioning from unrendered -> rendered
+					const stateNode = walkToNode(state.treeRoot, path);
+					writeValueToBackingDataStoreWithCorrections(path, state, restoreValueFromPotentialBackup(stateNode));
+				}
+			}
 			node.rendered = true;
 			return TreeMutatorResult.CONTINUE;
 		} else {
 			const newRendered = testCondition(condition, propertyValueResolverBuilder(path));
 			if (newRendered !== node.rendered) {
-				const dataStore = getDataStore(path[0], state, true);
-				let currentValue: any;
-				try {
-					currentValue = walkToNodeInValue(dataStore.getValue(path[0]), path);
-				} catch (e) {
-					if (!(e instanceof PathError)) {
-						throw e;
-					}
-					currentValue = undefined;
-				}
+				const {dataStore, currentValue} = getDataStoreAndCurrentValue(path, state);
 				if (!newRendered) {
 					// Create a backup if we are transitioning from rendered -> unrendered
 					recordBackupForNode(node, currentValue);
@@ -137,3 +136,15 @@ function performConditionChecks(state: Draft<DCStoreState>) {
 		}
 	});
 }
+
+function getDataStoreAndCurrentValue(path: NodePath, state: Draft<DCStoreState>) {
+	const dataStore = getDataStore(path[0], state, true);
+	try {
+		return {dataStore, currentValue: walkToNodeInValue(dataStore.getValue(path[0]), path)} as const;
+	} catch (e) {
+		if (!(e instanceof PathError)) {
+			throw e;
+		}
+		return {dataStore, currentValue: undefined} as const;
+	}
+}

package/src/blocks/data-controller/utils.ts

@@ -361,30 +361,30 @@ export function buildNodeFromDataAndDefinition(data: any, definition: HydratedSi
 	if (children) {
 		if (data === undefined || data === null) {
 			if (definition.type === 'array') {
-				return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
+				return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
 			} else if (definition.type === 'object') {
 				if (Array.isArray(children)) {
 					return {
-						rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "",
+						condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "",
 						children: Object.fromEntries(children.map(def => [def.name, buildNodeFromDataAndDefinition(undefined, def)]))
 					};
 				} else {
 					//TODO: We might need to throw an error here
-					return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: {}};
+					return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: {}};
 				}
 			}
 		} else if (typeof data === 'object') {
 			if (Array.isArray(data)) {
 				return {
-					rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: data.map(item => {
+					condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: data.map(item => {
 						const typedChildren = Array.isArray(children) ? children : children[item.type];
 						if (typedChildren === undefined) {
 							//TODO: We might need to throw an error here
-							return {children: [], rendered: true, validationError: ""};
+							return {children: [], validationError: ""};
 						}
 						return {
 							children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(item[def.name], def)])),
-							rendered: true, validationError: ""
+							validationError: ""
 						};
 					})
 				};
@@ -392,14 +392,14 @@ export function buildNodeFromDataAndDefinition(data: any, definition: HydratedSi
 				const typedChildren = Array.isArray(children) ? children : children[data.type];
 				if (typedChildren === undefined) {
 					//TODO: We might need to throw an error here
-					return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
+					return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
 				}
 				return {
-					rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "",
+					condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "",
 					children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(data[def.name], def)]))
 				};
 			}
 		}
 	}
-	return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: ""};
+	return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: ""};
 }

package/src/blocks/data-controller-manager.ts

@@ -2,7 +2,7 @@ import type {DataController} from "./simple-native-property-api";
 
 export type DataControllerManager = {
 	addDataController(blockClientId: string, dataController: DataController): void,
-	getDataController(blockClientId: string): DataController,
+	getDataController(blockClientId: string): DataController|undefined,
 	removeDataController(blockClientId: string): void,
 	notifyOfValidationErrorStatusChange(blockClientId: string, hasValidationError: boolean): void
 }
@@ -46,5 +46,5 @@ export function createDataControllerManager(): DataControllerManager {
 				return styleSheet.replace(`.block-editor-list-view-tree tbody tr:is(${blockMarkers}) {background: var(--plaudit-gae-validation-error-bg) !important;}`);
 			});
 		}
-	} as DataControllerManagerInternals;
+	} satisfies DataControllerManagerInternals as DataControllerManagerInternals;
 }

package/src/blocks/data-controller.ts

@@ -1,9 +1,8 @@
 import {useMemo} from "@wordpress/element";
 
-import {configureStore, Middleware, Tuple} from "@reduxjs/toolkit";
+import {configureStore, type Middleware, Tuple} from "@reduxjs/toolkit";
 
 import type {Dispatch} from "redux";
-import type {ThunkDispatch} from "redux-thunk";
 
 import {type Condition, resolveValueForCondition} from "./conditions";
 import {PathError, PathErrorType} from "./PathError";
@@ -11,7 +10,7 @@ import type {DataController, DataStore, HydratedSimpleNativeProperty, NodePath}
 
 import {actions, type DataControllerActions} from "./data-controller/actions";
 import {buildReducer} from "./data-controller/reducer";
-import {getDataStore, getOptionalValue, UUID, walkToNode} from "./data-controller/utils";
+import {getDataStore, getOptionalValue, type UUID, walkToNode} from "./data-controller/utils";
 
 type DescendantsWrapper = {[key: string]: DCNode}|DCNode[];
 export type DCNode = {
@@ -30,7 +29,6 @@ export type DCStoreState = {
 	rerenderTrigger: number,
 	batchAddedPropertiesThatNeedWriteThrough: HydratedSimpleNativeProperty<{uuid: UUID}>[]
 };
-type DCThunkDispatch = ThunkDispatch<DCStoreState, unknown, DataControllerActions>;
 
 export function useDataController(blockClientId: string): DataController {
 	return useMemo(() => {

package/src/blocks/hooks/useSuspendableOptions.ts

@@ -24,7 +24,7 @@ export function useSuspendableOptions<T extends CSNPConfig&{options: PromisableP
 			selectorInfo.searchParams.has("attributes"), selectorInfo, blockClientId);
 
 		// This if/else statement is present because actually passing attributes through to the selectors represents a SEVERE relative performance hit.
-		// At a minimum, it causes at leat one additional full execution pass, and, due to how data can be cached, that pass is almost guaranteed to turn into at least one full render.
+		// At a minimum, it causes at least one additional full execution pass, and, due to how data can be cached, that pass is almost guaranteed to turn into at least one full render.
 		let mapSelect: (...args: Parameters<MapSelect>) => [Record<string, any>|null, string|null];
 		if (usesBlockAttributes) {
 			mapSelect = wrappedSelect => {

package/src/blocks/simple-native-property-api.ts

@@ -5,8 +5,9 @@ import type {CSNPConfig} from "./csnp-api";
 import type {Condition} from "./conditions";
 import type {DCNode} from "./data-controller";
 import {installGutenbergExtensions} from "../index";
-import type {BlockName} from "../lib/useful-types";
+import {store as apiExtensionsStore} from "../lib/gutenberg-api-extensions-state";
 import type {HydratedLaidOutProperties} from "./simple-native-property-internal-shared";
+import type {BlockName} from "../lib/useful-types";
 
 import type {ReactElement, ReactNode} from "react";
 
@@ -22,7 +23,7 @@ export interface DataStore {
 
 	handlesProperty(name: string): boolean;
 
-	addProperty(property: HydratedSimpleNativeProperty, writeThroughOnUndefined?: boolean): void;
+	addProperty(property: HydratedSimpleNativeProperty): void;
 }
 export type RawPath = (string|number)[];
 export type NodePath = [string, ...(string|number)[]];
@@ -121,10 +122,10 @@ export type SimpleNativeTab = {
 export type PropertiesParameter = SimpleNativePanel|SimpleNativeTab|Array<LaidOutProperties[number]|SimpleNativePanel|SimpleNativeTab>;
 
 export function registerSimpleNativeProperties(config: {block: BlockName|Array<BlockName>, properties: PropertiesParameter}) {
-	dispatch('plaudit/gutenberg-api-extensions').addProperties(config.block, config.properties);
+	dispatch(apiExtensionsStore).addProperties(config.block, config.properties);
 }
 export function getSimpleNativeProperties(block: BlockName): Array<PDSimpleNativeProperty>|undefined {
-	const panelsAndTabs = select('plaudit/gutenberg-api-extensions').desiccatedProperties(block);
+	const panelsAndTabs = select(apiExtensionsStore).desiccatedProperties(block);
 	if (panelsAndTabs === undefined) {
 		return undefined;
 	}

package/src/blocks/simple-native-property-impl.tsx

@@ -276,7 +276,6 @@ function SNPPropsWrapper({blockSimpleNativePanelsAndTabs, blockEditProps, dataCo
 		}
 		dataController.checkConditions();
 		dataController.validateNodes();
-		dataController.commitBatchAddedProperties();
 	}, [blockSimpleNativePanelsAndTabs, dataController]); // We don't depend on blockEditProps here - that is handled by the following useEffect
 
 	// We have to reattach dataStores in the useMemo segment in order for Panel- and Tab-level conditions to work

package/src/blocks/snp-data-store.ts

@@ -1,7 +1,9 @@
 import {store as blockEditorStore} from "@wordpress/block-editor";
 import {dispatch, select} from "@wordpress/data";
 
-import {buildDefaultValueFromDefinition, UUID} from "./data-controller/utils";
+import {fastDeepEquals} from "../lib/modified-fast-deep-equals";
+
+import type {UUID} from "./data-controller/utils";
 import type {ActualBlockEditProps, BlockName} from "../lib/useful-types";
 import type {DataStore, HydratedSimpleNativeProperty} from "./simple-native-property-api";
 
@@ -30,8 +32,14 @@ export abstract class SNPDataStore implements DataStore {
 		return this.attributeCache[attr] = existingValue;
 	}
 	setValue(attr: string, value: any) {
-		this.attributeCache[attr] = value;
-		return this.setAttribute(attr, value);
+		const existingValue = this.getValue(attr);
+		if (!fastDeepEquals(existingValue, value)) {
+			this.attributeCache[attr] = value;
+			// WordPress doesn't handle saving and loading of empty objects consistently. As a result, we cannot safely write empty objects if the existing value is undefined
+			if (existingValue !== undefined || typeof value !== 'object' || !value || Object.entries(value).some(([, v]) => v !== undefined)) {
+				this.setAttribute(attr, value);
+			}
+		}
 	}
 	handlesProperty(name: string): boolean {
 		return name in this.managedPropertyNames;
@@ -58,18 +66,7 @@ export abstract class SNPDataStore implements DataStore {
 		return attr in this.attributeCache;
 	}
 
-	addProperty(property: HydratedSimpleNativeProperty<{uuid: UUID}>, writeThroughOnUndefined = true) {
-		if (this.managedPropertyNames[property.name]) {
-			return;
-		}
-		if (this.getAttribute(property.name) === undefined) {
-			if (writeThroughOnUndefined) {
-				this.setValue(property.name, buildDefaultValueFromDefinition(property));
-			} else {
-				this.attributeCache[property.name] = buildDefaultValueFromDefinition(property);
-			}
-		}
-
+	addProperty(property: HydratedSimpleNativeProperty<{uuid: UUID}>) {
 		this.managedPropertyNames[property.name] = true;
 	}
 }

package/src/controls/ExtendedTermPicker.tsx

@@ -5,6 +5,7 @@ import {useCallback} from "@wordpress/element";
 import type {SNPControlSlots} from "../blocks";
 import {ExtendedFormTokenField, unpackDisplayedTokenText, ValidationState} from "./ExtendedFormTokenField";
 import {registerSimpleGutenbergApiEndpoint} from "../editor/simple-gutenberg-endpoints-api";
+import {store as endpointsStore} from "../editor/simple-gutenberg-endpoints-impl";
 import type {TokenItem} from "../lib/useful-types";
 
 import type {ReactNode} from "react";
@@ -50,12 +51,10 @@ export function ExtendedTermPicker(props: ExtendedTermPickerProps) {
 	const {taxonomy} = props;
 
 	const suggestionQuery = useCallback((input: string, select: typeof dataSelect) => {
-		return select('plaudit/simple-gutenberg-apis')
-			.get("plaudit-common.term-table-search-options", {search: input, taxonomy}) as TokenItem[]|undefined;
+		return select(endpointsStore).get("plaudit-common.term-table-search-options", {search: input, taxonomy}) as TokenItem[]|undefined;
 	}, [taxonomy]);
 	const validationQuery = useCallback((slugsBeingValidated: string[], select: typeof dataSelect) => {
-		return (select('plaudit/simple-gutenberg-apis')
-			.get("plaudit-common.term-table-search-validation", {slugs: slugsBeingValidated.join(','), taxonomy}) as TokenItem[]|undefined);
+		return select(endpointsStore).get("plaudit-common.term-table-search-validation", {slugs: slugsBeingValidated.join(','), taxonomy}) as TokenItem[]|undefined;
 	}, [taxonomy]);
 
 	return <ExtendedFormTokenField {...props} validationQuery={validationQuery} suggestionQuery={suggestionQuery} stringToTokenConverter={unpackDisplayedTokenText} />;

package/src/controls/basicNumericallyIdedItemPicker.tsx

@@ -3,6 +3,7 @@ import {useCallback} from "@wordpress/element";
 
 import type {SNPControlSlots} from "../blocks";
 import {ExtendedFormTokenField, unpackDisplayedTokenText, ValidationState} from "./ExtendedFormTokenField";
+import {store as endpointsStore} from "../editor/simple-gutenberg-endpoints-impl";
 import {isNumeric} from "./shared";
 import type {TokenItem} from "../lib/useful-types";
 
@@ -29,12 +30,10 @@ export function basicNumericallyIdedItemPicker(props: BasicNumericallyIdedItemPi
 	const {multiple, value, ...remainder} = props;
 
 	const suggestionQuery = useCallback((input: string, select: typeof dataSelect) => {
-		return select('plaudit/simple-gutenberg-apis')
-			.get(endpoint + "-options", {search: input, ...queryProps}) as TokenItem[]|undefined;
+		return select(endpointsStore).get(endpoint + "-options", {search: input, ...queryProps}) as TokenItem[]|undefined;
 	}, [queryProps]);
 	const validationQuery = useCallback((idsBeingValidated: string[], select: typeof dataSelect) => {
-		return (select('plaudit/simple-gutenberg-apis')
-			.get(endpoint + "-validation", {ids: idsBeingValidated.join(','), ...queryProps}) as TokenItem[]|undefined);
+		return select(endpointsStore).get(endpoint + "-validation", {ids: idsBeingValidated.join(','), ...queryProps}) as TokenItem[]|undefined;
 	}, [queryProps]);
 
 	if (props.multiple === false) {

package/src/index.ts

@@ -1,16 +1,19 @@
 import {installSimpleNativePropertiesSupport} from "./blocks/simple-native-property-impl";
-import {installSimpleGutenbergApisSupport, type store as endpointStore} from "./editor/simple-gutenberg-endpoints-impl";
-import {registerStore, type store as apiStore} from "./lib/gutenberg-api-extensions-state";
+import {installSimpleGutenbergApisSupport, store as endpointsStore} from "./editor/simple-gutenberg-endpoints-impl";
+import {registerStore, store as apiExtensionsStore} from "./lib/gutenberg-api-extensions-state";
 
 export * from "./blocks";
 export * from "./controls";
 export * from "./editor/simple-gutenberg-endpoints-api";
 export {TemporalLRUCache, useAdoptedStyleSheet} from "./lib/helpers";
+export * from "./lib/modified-fast-deep-equals";
 export * from "./lib/plaudit-icons";
 export * as SectionedCacheStore from "./lib/sectioned-cache-store";
 export * from "./lib/suspense";
 export type * from "./lib/useful-types";
 
+export {apiExtensionsStore, endpointsStore};
+
 export function installGutenbergExtensions() {
 	if (!installGutenbergExtensions.called) {
 		installGutenbergExtensions.called = true;
@@ -22,11 +25,3 @@ export function installGutenbergExtensions() {
 export namespace installGutenbergExtensions {
 	export let called: boolean = false;
 }
-
-declare module "@wordpress/data" {
-	function select(key: 'plaudit/gutenberg-api-extensions'): ReturnType<typeof select<typeof apiStore>>;
-	function dispatch(key: 'plaudit/gutenberg-api-extensions'): ReturnType<typeof dispatch<typeof apiStore>>;
-
-	function select(key: 'plaudit/simple-gutenberg-apis'): ReturnType<typeof select<typeof endpointStore>>;
-	function dispatch(key: 'plaudit/simple-gutenberg-apis'): ReturnType<typeof dispatch<typeof endpointStore>>;
-}

package/src/lib/modified-fast-deep-equals.ts

@@ -0,0 +1,91 @@
+/**
+ * This is a modified copy of https://github.com/epoberezkin/fast-deep-equal that treats "not present" and "present but undefined" as equivalent
+ */
+export function fastDeepEquals(a: unknown, b: unknown) {
+	if (a === b) return true;
+
+	if (a && b && typeof a === 'object' && typeof b === 'object') {
+		if (a.constructor !== b.constructor) return false;
+
+		if (Array.isArray(a)) {
+			if (!Array.isArray(b)) {
+				return false;
+			}
+
+			const length = a.length;
+			if (length !== b.length) return false;
+			for (let i = length - 1; i >= 0; i--) {
+				if (!fastDeepEquals(a[i], b[i])) return false;
+			}
+			return true;
+		}
+
+
+		if (a instanceof Map) {
+			if (!(b instanceof Map)) {
+				return false;
+			}
+
+			for (const [key, value] of b.entries()) {
+				if (value !== undefined && !a.has(key)) {
+					return false;
+				}
+			}
+			for (const [key, value] of a.entries()) {
+				if (value !== undefined && !b.has(key)) {
+					return false;
+				}
+				if (!fastDeepEquals(value, b.get(key))) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		if (a instanceof Set) {
+			if (!(b instanceof Set)) {
+				return false;
+			}
+			if (a.size !== b.size) {
+				return false;
+			}
+			for (const key of a.keys()) {
+				if (!b.has(key)) return false;
+			}
+			return true;
+		}
+
+		if (a instanceof RegExp) {
+			return b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+		}
+
+		if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+		if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+		for (const [key, value] of Object.entries(b)) {
+			if (value !== undefined && !(key in a)) {
+				return false;
+			}
+		}
+		for (const [key, value] of Object.entries(a)) {
+			if (key === '_owner' && "$$typeof" in a) {
+				// React-specific: avoid traversing React elements' _owner.
+				//  _owner contains circular references
+				// and is not needed when comparing the actual elements (and not their owners)
+				continue;
+			}
+			if (value !== undefined) {
+				if (!fastDeepEquals(value, b[key as keyof typeof b])) {
+					return false;
+				}
+			} else if (key in b && b[key as keyof typeof b] !== undefined) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	// true if both NaN, false otherwise
+	return a!==a && b!==b;
+}