@plaudit/gutenberg-api-extensions 2.84.2 → 2.84.4

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

@@ -5,7 +5,6 @@ import {Draft, produce} from "immer";
 import type {DCNode, DCStoreState} from "../data-controller";
 import {MoveError} from "../MoveError";
 import {PathError, PathErrorType} from "../PathError";
-import {buildDefaultValueFromDefinition} from "../simple-native-property-internal-shared";
 import type {DataStore, HydratedSimpleNativeProperty, NodePath, RawPath} from "../simple-native-property-api";
 
 export function removeFromParentNode(parentNode: any|undefined, path: RawPath) {
@@ -58,14 +57,14 @@ export function isNumericMove(move: {from: number, to: number}|{from: string, to
 	return typeof move.from === 'number' && typeof move.to === 'number';
 }
 
-export function resolveParentNodeDefinition(root: DCNode, path: RawPath): HydratedSimpleNativeProperty|undefined {
+export function resolveParentNodeDefinition(root: DCNode, path: RawPath): DCNode['definition'] {
 	if (path.length < 2) {
 		throw new PathError("Unable to get the parent node of a path with less than two nodes", path, path.length - 1, PathErrorType.INSUFFICIENT_LENGTH);
 	}
 	return walkToNode(root, path.slice(0, path.length - (typeof path[path.length - 2] === 'number' ? 2 : 1))).definition;
 }
 
-export function populateValueBasedOnDefinition(value: any, definition: HydratedSimpleNativeProperty|undefined): any {
+export function populateValueBasedOnDefinition(value: any, definition: HydratedSimpleNativeProperty<{uuid: UUID}>|undefined): any {
 	const typedChildren = Array.isArray(definition?.children) ? definition.children : definition?.children?.[value?.type];
 	if (!typedChildren?.length) {
 		return value ?? buildDefaultValueFromDefinition(definition);
@@ -166,7 +165,7 @@ export function writeValueToBackingDataStoreWithCorrections(path: NodePath, stat
 	const dataStore = getDataStore(path[0], state);
 
 	// This path both handles scalar values and ensures that the root "value" of Groups and Lists are initialized before writing the actual attribute
-	// In order to avoid accidentally overwriting group data when lazily adding items (i.e. via a ToolsPanel instance), we skip this code path if the group's root value has already been initialized
+	// To avoid accidentally overwriting group data when lazily adding items (i.e., via a ToolsPanel instance), we skip this code path if the group's root value has already been initialized
 	if (path.length === 1 || (value === undefined && dataStore.getValue(path[0]) === undefined)) {
 		const writtenValue = value ?? buildDefaultValueFromDefinition(rootDCNode.definition, path.length === 1);
 		dataStore.setValue(path[0], writtenValue);
@@ -290,27 +289,71 @@ export function applyToTree(tree: DCNode, mutator: (node: DCNode, path: NodePath
 	return TreeMutatorResult.CONTINUE;
 }
 
-export function buildNodeFromDataAndDefinition(data: any, definition: HydratedSimpleNativeProperty): DCNode {
+export type UUID = ReturnType<typeof crypto.randomUUID>;
+const cloneableDefaultValuesForNodes: Record<UUID, HydratedSimpleNativeProperty['default']> = {};
+export function recordCloneableDefaultValueForNode<T extends HydratedSimpleNativeProperty<{uuid?: UUID}>>(definition: T) {
+	if (!definition.uuid) {
+		definition.uuid = crypto.randomUUID();
+	}
+	if (!(definition.uuid in cloneableDefaultValuesForNodes)) {
+		try {
+			cloneableDefaultValuesForNodes[definition.uuid] = (definition.default === undefined ? undefined : structuredClone(definition.default));
+		} catch (e) {
+			console.error(`Encountered an unexpected un-cloneable default value: ${e}`);
+		}
+	}
+
+	return definition as HydratedSimpleNativeProperty<{uuid: UUID}>;
+}
+
+export function buildDefaultValueFromDefinition(definition: (HydratedSimpleNativeProperty<{uuid: UUID}>)|undefined, requireNonNullValueOnObject = true): any {
+	if (definition === undefined) {
+		return undefined;
+	} else if (definition.default !== undefined) {
+		return structuredClone(definition.uuid in cloneableDefaultValuesForNodes ? cloneableDefaultValuesForNodes[definition.uuid] : definition.default);
+	}
+	const typedChildren = Array.isArray(definition.children) ? definition.children : undefined;
+	if (!typedChildren?.length) {
+		return structuredClone(definition.uuid in cloneableDefaultValuesForNodes ? cloneableDefaultValuesForNodes[definition.uuid] : definition.default);
+	} else if (definition.type === 'array') {
+		return [];
+	} else if (definition.type !== 'object') {
+		return undefined;
+	}
+
+	const res = Object.fromEntries(typedChildren.map(def => [def.name, buildDefaultValueFromDefinition(def)]));
+	if (requireNonNullValueOnObject) {
+		for (const value of Object.values(res)) {
+			if (value !== undefined) {
+				return res;
+			}
+		}
+		return undefined;
+	}
+	return res;
+}
+
+export function buildNodeFromDataAndDefinition(data: any, definition: HydratedSimpleNativeProperty<{uuid?: UUID}>): DCNode {
 	const children = definition.children;
 	if (children) {
 		if (data === undefined || data === null) {
 			if (definition.type === 'array') {
-				return {rendered: true, condition: definition.condition, definition, validationError: "", children: []};
+				return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
 			} else if (definition.type === 'object') {
 				if (Array.isArray(children)) {
 					return {
-						rendered: true, condition: definition.condition, definition, validationError: "",
+						rendered: true, 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, validationError: "", children: {}};
+					return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: {}};
 				}
 			}
 		} else if (typeof data === 'object') {
 			if (Array.isArray(data)) {
 				return {
-					rendered: true, condition: definition.condition, definition, validationError: "", children: data.map(item => {
+					rendered: true, 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
@@ -326,14 +369,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, validationError: "", children: []};
+					return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
 				}
 				return {
-					rendered: true, condition: definition.condition, definition, validationError: "",
+					rendered: true, 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, validationError: ""};
+	return {rendered: true, condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: ""};
 }

package/src/blocks/data-controller.ts

@@ -9,11 +9,9 @@ import {type Condition, resolveValueForCondition} from "./conditions";
 import {PathError, PathErrorType} from "./PathError";
 import type {DataController, DataStore, HydratedSimpleNativeProperty, NodePath} from "./simple-native-property-api";
 
-import {actions, DataControllerActions} from "./data-controller/actions";
+import {actions, type DataControllerActions} from "./data-controller/actions";
 import {buildReducer} from "./data-controller/reducer";
-import {getDataStore, getOptionalValue, walkToNode} from "./data-controller/utils";
-
-export type {DataControllerActions} from "./data-controller/actions";
+import {getDataStore, getOptionalValue, UUID, walkToNode} from "./data-controller/utils";
 
 type DescendantsWrapper = {[key: string]: DCNode}|DCNode[];
 export type DCNode = {
@@ -21,7 +19,7 @@ export type DCNode = {
 	rendered?: boolean,
 	condition?: Condition,
 	children?: DescendantsWrapper,
-	definition?: HydratedSimpleNativeProperty,
+	definition?: HydratedSimpleNativeProperty<{uuid: UUID}>,
 	validationError?: string
 };
 export type DCStoreState = {
@@ -30,7 +28,7 @@ export type DCStoreState = {
 	blockClientId: string,
 	changedByManagedControl: boolean,
 	rerenderTrigger: number,
-	batchAddedPropertiesThatNeedWriteThrough: HydratedSimpleNativeProperty[]
+	batchAddedPropertiesThatNeedWriteThrough: HydratedSimpleNativeProperty<{uuid: UUID}>[]
 };
 type DCThunkDispatch = ThunkDispatch<DCStoreState, unknown, DataControllerActions>;
 

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

@@ -94,8 +94,8 @@ export type SimpleNativeProperty = GenericSimpleNativeProperty<string, 'string'>
 export type PDSimpleNativeProperty = SimpleNativeProperty|CSNPConfig;
 export type PotentiallyDesiccatedSimpleNativeProperty = PDSimpleNativeProperty;
 
-export type HydratedSimpleNativeProperty = SimpleNativeProperty
-	&{children?: {[subtype: string]: HydratedSimpleNativeProperty[]}|HydratedSimpleNativeProperty[], controlType?: string, branching?: boolean, initializing?: ReactNode|(() => ReactNode)};
+export type HydratedSimpleNativeProperty<ADDITIONAL_DATA extends Record<string, any> = {}> = SimpleNativeProperty&ADDITIONAL_DATA
+	&{children?: {[subtype: string]: HydratedSimpleNativeProperty<ADDITIONAL_DATA>[]}|HydratedSimpleNativeProperty<ADDITIONAL_DATA>[], controlType?: string, branching?: boolean, initializing?: ReactNode|(() => ReactNode)};
 export type SNPControlSlots = {Label: ProvidedSlot, Messages: ProvidedSlot};
 
 export type LaidOutProperties = Array<PDSimpleNativeProperty|Array<PDSimpleNativeProperty>>;

package/src/blocks/simple-native-property-internal-shared.ts

@@ -17,30 +17,3 @@ export type PreppedSimpleNativePanelsAndTabs = {panels: [string, HydratedSimpleN
 export function isRootLevelPanelGroup(panelGroup: string|undefined) {
 	return panelGroup === undefined || panelGroup === "default" || panelGroup === "advanced" || panelGroup === "settings" || panelGroup === "styles";
 }
-
-export function buildDefaultValueFromDefinition(definition: HydratedSimpleNativeProperty|undefined, requireNonNullValueOnObject = true): any {
-	if (definition === undefined) {
-		return undefined;
-	} else if (definition.default !== undefined) {
-		return structuredClone(definition.default);
-	}
-	const typedChildren = Array.isArray(definition.children) ? definition.children : undefined;
-	if (!typedChildren?.length) {
-		return structuredClone(definition.default);
-	} else if (definition.type === 'array') {
-		return [];
-	} else if (definition.type !== 'object') {
-		return undefined;
-	}
-
-	const res = Object.fromEntries(typedChildren.map(def => [def.name, buildDefaultValueFromDefinition(def)]));
-	if (requireNonNullValueOnObject) {
-		for (const value of Object.values(res)) {
-			if (value !== undefined) {
-				return res;
-			}
-		}
-		return undefined;
-	}
-	return res;
-}

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

@@ -1,9 +1,9 @@
 import {store as blockEditorStore} from "@wordpress/block-editor";
 import {dispatch, select} from "@wordpress/data";
 
+import {buildDefaultValueFromDefinition, UUID} from "./data-controller/utils";
 import type {ActualBlockEditProps, BlockName} from "../lib/useful-types";
 import type {DataStore, HydratedSimpleNativeProperty} from "./simple-native-property-api";
-import {buildDefaultValueFromDefinition} from "./simple-native-property-internal-shared";
 
 export abstract class SNPDataStore implements DataStore {
 	private readonly managedPropertyNames: {[propertyName in string]: true};
@@ -58,7 +58,7 @@ export abstract class SNPDataStore implements DataStore {
 		return attr in this.attributeCache;
 	}
 
-	addProperty(property: HydratedSimpleNativeProperty, writeThroughOnUndefined = true) {
+	addProperty(property: HydratedSimpleNativeProperty<{uuid: UUID}>, writeThroughOnUndefined = true) {
 		if (this.managedPropertyNames[property.name]) {
 			return;
 		}

package/src/lib/gutenberg-api-extensions-state/custom-block-bindings-support-logic.ts

@@ -1,9 +1,10 @@
 import {registerBlockBindingsSource} from "@wordpress/blocks";
 
-import type {DbSource} from "../../blocks";
-import type {WordPressMetaActions} from "../useful-types";
 import {produce} from "immer";
 
+import type {DbSource} from "../../blocks";
+import type {WorkableUnknownAction} from "../useful-types";
+
 export type CustomBlockBindingsSupportLogicActions = {type: 'ADD_CUSTOM_BLOCK_BINDINGS_SOURCE', name: string, value: {dbSources?: DbSource[]}};
 export type CustomBlockBindingsSupportLogicState = {
 	customBlockBindingsSupport: {[name in string]?: {dbSources?: DbSource[]}}
@@ -23,7 +24,7 @@ export const customBlockBindingsSupportLogicSelectors = {
 };
 
 export function customBlockBindingsSupportLogic(
-	state: CustomBlockBindingsSupportLogicState, action: CustomBlockBindingsSupportLogicActions|WordPressMetaActions
+	state: CustomBlockBindingsSupportLogicState, action: CustomBlockBindingsSupportLogicActions|WorkableUnknownAction
 ): typeof state {
 	if (action.type === "ADD_CUSTOM_BLOCK_BINDINGS_SOURCE") {
 		return produce(state, (draft: typeof state) => {

package/src/lib/gutenberg-api-extensions-state/layered-block-styles-logic.ts

@@ -2,7 +2,7 @@ import {produce} from "immer";
 
 import type {PDSimpleNativeProperty} from "../../blocks";
 import type {NamedBlockAction} from "../gutenberg-api-extensions-state";
-import type {BlockName, WordPressMetaActions} from "../useful-types";
+import type {BlockName, WorkableUnknownAction} from "../useful-types";
 
 export type LayeredBlockStylesLogicActions =
 	NamedBlockAction<'ADD_LAYERED_BLOCK_STYLES', {properties: PDSimpleNativeProperty[]}>|
@@ -25,7 +25,7 @@ export const layeredBlockStylesLogicSelectors = {
 	}
 };
 
-export function layeredBlockStylesLogic(state: LayeredBlockStylesLogicState, action: LayeredBlockStylesLogicActions|WordPressMetaActions): typeof state {
+export function layeredBlockStylesLogic(state: LayeredBlockStylesLogicState, action: LayeredBlockStylesLogicActions|WorkableUnknownAction): typeof state {
 	switch (action.type) {
 		case "ADD_LAYERED_BLOCK_STYLES":
 			return produce(state, (draft: typeof state) => {

package/src/lib/gutenberg-api-extensions-state/snp-logic.ts

@@ -13,7 +13,7 @@ import type {
 	PreppedSimpleNativePanelsAndTabs
 } from "../../blocks/simple-native-property-internal-shared";
 import {BareProperties, NamedBlockAction, store} from "../gutenberg-api-extensions-state";
-import {BlockName, isBlockJsonNativePropsConfig, RegisterBlockAttrs, WordPressMetaActions} from "../useful-types";
+import {BlockName, isBlockJsonNativePropsConfig, RegisterBlockAttrs, WorkableUnknownAction} from "../useful-types";
 
 export type SNPLogicState = {
 	desiccatedProperties: {[blockName in BlockName]?: Array<SimpleNativePanel|SimpleNativeTab>},
@@ -67,7 +67,7 @@ export const snpLogicSelectors = {
 	}
 };
 
-export function snpLogic(state: SNPLogicState, action: SNPLogicActions|WordPressMetaActions) {
+export function snpLogic(state: SNPLogicState, action: SNPLogicActions|WorkableUnknownAction) {
 	switch (action.type) {
 		case "ADD_PROPERTIES":
 			return produce(state, (draft: typeof state) => {

package/src/lib/gutenberg-api-extensions-state.ts

@@ -10,7 +10,7 @@ import {
 	layeredBlockStylesLogic, layeredBlockStylesLogicActions, LayeredBlockStylesLogicActions, layeredBlockStylesLogicSelectors, LayeredBlockStylesLogicState
 } from "./gutenberg-api-extensions-state/layered-block-styles-logic";
 import {snpLogic, snpLogicActions, SNPLogicActions, snpLogicSelectors, SNPLogicState} from "./gutenberg-api-extensions-state/snp-logic";
-import {combineSelectors, withExposedWordpressMetadata} from "./helpers";
+import {combineSelectors} from "./helpers";
 import type {BlockName} from "./useful-types";
 
 export type State = {
@@ -42,7 +42,7 @@ const DEFAULT_STATE: State = {
 
 type ReducerActions = CustomBlockBindingsSupportLogicActions|LayeredBlockStylesLogicActions|SNPLogicActions|GeneralLogicActions;
 
-export const store = createReduxStore('plaudit/gutenberg-api-extensions', withExposedWordpressMetadata({
+export const store = createReduxStore('plaudit/gutenberg-api-extensions', {
 	initialState: DEFAULT_STATE,
 	reducer: combineReducers({
 		customBlockBindingsSupportLogic,
@@ -62,7 +62,7 @@ export const store = createReduxStore('plaudit/gutenberg-api-extensions', withEx
 		snpLogic: snpLogicSelectors,
 		generalLogic: generalLogicSelectors
 	})
-}));
+});
 
 export function registerStore() {
 	register(store);

package/src/lib/helpers.ts

@@ -1,10 +1,4 @@
-import {type ActionCreator, type ReduxStoreConfig, resolveSelect, type select} from "@wordpress/data";
-import type * as MetaActions from "@wordpress/data/redux-store/metadata/actions";
-import type * as MetaSelectors from "@wordpress/data/redux-store/metadata/selectors";
-
-import type {store as apiStore} from "./gutenberg-api-extensions-state";
-import type {store as endpointsStore} from "../editor/simple-gutenberg-endpoints-impl";
-import type {PromisifyFunctionReturns, SubsequentArgsOfFunc} from "./useful-types";
+import type {SubsequentArgsOfFunc} from "./useful-types";
 
 export function clone<T>(value: T): T {
 	if (value === null || value === undefined) {
@@ -15,14 +9,6 @@ export function clone<T>(value: T): T {
 	return typeof value === 'object' ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, clone(v)])) as T : value;
 }
 
-type Mapping<K> = K extends 'plaudit/gutenberg-api-extensions'|(typeof apiStore)
-	? PromisifyFunctionReturns<ReturnType<typeof select<typeof apiStore>>>
-	: K extends 'plaudit/simple-gutenberg-apis'|(typeof endpointsStore)
-		? PromisifyFunctionReturns<ReturnType<typeof select<typeof endpointsStore>>>
-		: never;
-export const fixedResolveSelect:
-	(<K extends 'plaudit/gutenberg-api-extensions'|(typeof apiStore)|'plaudit/simple-gutenberg-apis'|(typeof endpointsStore)>(key: K) => Mapping<K>) = resolveSelect;
-
 // This is madness. I do not know why it works, only that it does.
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 
@@ -51,14 +37,6 @@ export function combineSelectors<S extends SelectorsArg<any>>(selectors: S) {
 	})) as CombinedSelectors<typeof selectors>;
 }
 
-export function withExposedWordpressMetadata<
-	State, Actions extends Record<Exclude<string, keyof typeof MetaActions>, ActionCreator>, Selectors extends Omit<Selectors, keyof typeof MetaSelectors>
->(
-	options: ReduxStoreConfig<State, Actions, Selectors>
-): Omit<typeof options, 'actions'|'selectors'>&{actions: (typeof MetaActions)&(typeof options)['actions'], selectors: (typeof MetaSelectors)&(typeof options)['selectors']} {
-	return options as any;
-}
-
 export class TemporalLRUCache<K, V extends NonNullable<any>|undefined> {
 	private readonly cache: Map<K, [V, number]> = new Map();
 	private timeout?: ReturnType<Window['setTimeout']>;

package/src/lib/useful-types.ts

@@ -1,18 +1,12 @@
-import {Block, BlockSupports} from "@wordpress/blocks";
-import {dispatch, select, StoreDescriptor} from "@wordpress/data";
-import {FormTokenField} from '@wordpress/components';
-import type * as MetaActions from "@wordpress/data/redux-store/metadata/actions";
-import type * as MetaSelectors from "@wordpress/data/redux-store/metadata/selectors";
+import type {Block, BlockSupports} from "@wordpress/blocks";
+import type {FormTokenField} from '@wordpress/components';
 
 import type {ComponentProps} from "react";
 
 import type {PropertiesParameter} from "../blocks";
 
-export type TokenItem = Exclude<NonNullable<ComponentProps<typeof FormTokenField>['value']>[number], string>
-
-export type NormalizedReduxActionExtractor<V> = V extends {[key in string]: (...args: any[]) => infer R}
-	? NormalizedReduxActionExtractor<R> : V extends {type: string} ? V : (V extends (...args: any[]) => {type: string} ? ReturnType<V> : never);
-export type WordPressMetaActions = NormalizedReduxActionExtractor<typeof MetaActions>;
+export type TokenItem = Exclude<NonNullable<ComponentProps<typeof FormTokenField>['value']>[number], string>;
+export type WorkableUnknownAction = {type: "@@UNKNOWN_ACTION"};
 
 export type SubsequentArgsOfFunc<F> = F extends (arg: any, ...args: infer R) => any ? R : never;
 
@@ -45,16 +39,6 @@ export type NonEmptyArray<T> = [T, ...T[]];
 export function arrayIsNotEmpty<T>(arr: T[]|null|undefined): arr is NonEmptyArray<T> {
 	return !!arr && arr.length > 0;
 }
-
-type CurriedWordPressMetaSelectors = {[key in keyof typeof MetaSelectors]: (...args: SubsequentArgsOfFunc<(typeof MetaSelectors)[key]>) => ReturnType<(typeof MetaSelectors)[key]>};
-export type MinThunkParams<S, A> = {
-	select<R>(selector: (state: {root: S}) => R): R, dispatch(action: A|WordPressMetaActions): Promise<unknown>, resolveSelect: any
-};
-export type ThunkParams<T extends StoreDescriptor, S, A> = {
-	select: ReturnType<typeof select<T>>&{<R>(selector: (state: {root: S}) => R): R},
-	dispatch: ReturnType<typeof dispatch<T>>&{(action: A|(typeof MetaActions)): Promise<unknown>},
-	resolveSelect: PromisifyFunctionReturns<ReturnType<typeof select<T>>>
-};
 export type PromisifyFunctionReturns<T extends {[K in string]: (...args: any[]) => any}> = {[K in keyof T]: (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>};
 
 export type WPTaxonomyQuery = {