@plaudit/gutenberg-api-extensions 2.95.0 → 2.96.0

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

@@ -1,150 +0,0 @@
-import {ActionReducerMapBuilder, CaseReducer, createAction, PayloadAction, PayloadActionCreator} from "@reduxjs/toolkit";
-import type {Draft} from "immer";
-
-import type {NodePath, RawPath} from "../simple-native-property-api";
-import {PathError} from "../PathError";
-import type {DCNode, DCStoreState} from "../data-controller";
-import {resolveValueForCondition, testCondition} from "../conditions";
-import {
-	applyToTree,
-	getDataStore,
-	getOptionalValue,
-	recordBackupForNode,
-	removeValueFromBackingDataStore,
-	restoreValueFromPotentialBackup,
-	TreeMutatorResult,
-	walkToNode,
-	walkToNodeInValue,
-	writeValueToBackingDataStore,
-	writeValueToBackingDataStoreWithCorrections,
-} from "./utils";
-
-type BasePayload = {[key in string]: any}&{type?: never, inBatch?: never};
-type BaseMetadata = {[key in string]: any}&{inBatch?: never};
-type BaseReducer<State, P extends BasePayload, M extends BaseMetadata> = CaseReducer<State, PayloadAction<P, string, M&{inBatch?: boolean}>>;
-function makeTriggerHandler<State, P extends BasePayload = {}, M extends BaseMetadata = {}>(reducer: BaseReducer<State, P, M>) {
-	type ActionType = PayloadAction<P, string, M&{inBatch?: boolean}>&{meta: M&{inBatch?: boolean}};
-	type TriggeringActionCreator = PayloadActionCreator<P, string, (...args: any[]) => {payload: P, meta: M&{inBatch?: boolean}}>;
-	const triggeringActionCreators: TriggeringActionCreator[] = [];
-	const isInstance = (action: any): action is ActionType => {
-		return triggeringActionCreators.some(actionCreator => actionCreator.match(action));
-	};
-	const shouldTrigger = (action: any): action is ActionType => isInstance(action) && (action.meta.inBatch !== true);
-	return {
-		addAction: (action: TriggeringActionCreator) => triggeringActionCreators.push(action), isInstance, shouldTrigger,
-		attachTo:  (builder: ActionReducerMapBuilder<State>) => builder.addMatcher(shouldTrigger, reducer)
-	}
-}
-
-export const triggerHandlers = {
-	validation: makeTriggerHandler<DCStoreState, {path: NodePath}>((state, {payload: {path}}) => {
-		validateNode(path, state);
-		return state;
-	}),
-	conditionChecks: makeTriggerHandler<DCStoreState>(performConditionChecks),
-	changedByManagedControl: makeTriggerHandler<DCStoreState>(state => {
-		state.changedByManagedControl = true;
-	}),
-} as const;
-
-type CommonTriggers = {changedByManagedControl?: boolean, conditionChecks?: boolean};
-type BaseActionMeta<ADDITIONAL_TRIGGERS extends {[K in Exclude<keyof typeof triggerHandlers, keyof CommonTriggers>]?: boolean}> = {inBatch?: boolean, triggers: CommonTriggers&ADDITIONAL_TRIGGERS};
-
-export type GlobalActionMeta = BaseActionMeta<{}>;
-export function createGlobalAction<P extends {[key: Exclude<string, 'type'|'inBatch'>]: any} = {}, T extends string = string>(type: T, triggers: GlobalActionMeta['triggers'] = {}) {
-	const res = createAction(type, (payload: P, inBatch: boolean = false) => ({payload, meta: {inBatch, triggers}}));
-	for (const [trigger, enabled] of Object.entries(triggers)) {
-		if (enabled) {
-			triggerHandlers[trigger as keyof typeof triggers].addAction(res);
-		}
-	}
-	return res;
-}
-
-export type PathedActionMeta = BaseActionMeta<{validation?: boolean}>;
-export function createPathedAction<P extends {[key: Exclude<string, 'type'|'path'|'inBatch'>]: any} = {}, T extends string = string>(type: T, triggers: PathedActionMeta['triggers'] = {}) {
-	const res = createAction(type, (payload: P&{path: NodePath}, inBatch: boolean = false) => ({payload, meta: {inBatch, triggers}}));
-	for (const [trigger, enabled] of Object.entries(triggers)) {
-		if (enabled) {
-			triggerHandlers[trigger as keyof typeof triggers].addAction(res);
-		}
-	}
-	return res;
-}
-
-export function validateNode(path: NodePath, draft: Draft<DCStoreState>) {
-	if (validateFoundNode(walkToNode(draft.treeRoot, path), path, draft)) {
-		draft.rerenderTrigger = draft.rerenderTrigger + 1;
-	}
-}
-
-/**
- * @return true iff the validation state changed
- */
-export function validateFoundNode(node: DCNode, path: NodePath, draft: Draft<DCStoreState>) {
-	const definition = node.definition;
-	if (definition) {
-		let validationError: string;
-		const value = getOptionalValue(path, draft);
-		if (definition.required && !value) {
-			validationError = `"${definition.label || definition.name}" is required.`;
-		} else {
-			validationError = definition.validator?.(value) ?? "";
-		}
-		if (node.validationError !== validationError) {
-			node.validationError = validationError;
-			return true;
-		}
-	}
-	return false;
-}
-
-type PropertyValueResolverBuilder = (path: RawPath) => (propertyPath: RawPath) => any;
-function performConditionChecks(state: Draft<DCStoreState>) {
-	const blockClientId = state.blockClientId;
-	const propertyValueResolverBuilder: PropertyValueResolverBuilder =
-		path => propertyPath => resolveValueForCondition(propertyPath, path, blockClientId,
-			property => getDataStore(property, state, false));
-	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, currentValue} = getDataStoreAndCurrentValue(path, state);
-				if (!newRendered) {
-					// Create a backup if we are transitioning from rendered -> unrendered
-					recordBackupForNode(node, currentValue);
-					removeValueFromBackingDataStore(dataStore, path);
-				} else if (currentValue === undefined) {
-					// Restore from backup if we are transitioning from unrendered -> rendered
-					const stateNode = walkToNode(state.treeRoot, path);
-					writeValueToBackingDataStore(dataStore, path, restoreValueFromPotentialBackup(stateNode));
-				}
-				node.rendered = newRendered;
-			}
-			return node.rendered ? TreeMutatorResult.CONTINUE : TreeMutatorResult.SKIP_DESCENDANTS;
-		}
-	});
-}
-
-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

@@ -1,415 +0,0 @@
-import {doAction} from "@wordpress/hooks";
-
-import {Draft, produce} from "immer";
-
-import type {DCNode, DCStoreState} from "../data-controller";
-import {MoveError} from "../MoveError";
-import {PathError, PathErrorType} from "../PathError";
-import type {DataStore, HydratedSimpleNativeProperty, NodePath, RawPath} from "../simple-native-property-api";
-
-export function removeFromParentNode(parentNode: any|undefined, path: RawPath) {
-	if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
-		throw new PathError("Encountered a non-existent node while expecting one.", path);
-	}
-	const nodeName = path[path.length - 1];
-	if (typeof nodeName === 'string') {
-		if (Array.isArray(parentNode)) {
-			throw new PathError(
-				"Encountered a node with indexed descendants while expecting one with string-keyed descendants.",
-				path, path.length - 1);
-		}
-		delete parentNode[nodeName];
-	} else if (nodeName === undefined) {
-		throw new PathError("Encountered an undefined name in a path.", path);
-	} else {
-		if (!Array.isArray(parentNode)) {
-			throw new PathError(
-				"Encountered a node with string-keyed descendants while expecting one with indexed descendants.",
-				path, path.length - 1);
-		}
-		parentNode.splice(nodeName, 1);
-	}
-}
-
-export function moveNodeWithinParent(parentNode: any|undefined|null, path: RawPath, move: {from: number, to: number}|{from: string, to: string}) {
-	if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
-		throw new PathError("Encountered a non-existent node while expecting one.", path);
-	}
-	if (isNumericMove(move)) {
-		if (!Array.isArray(parentNode)) {
-			throw new MoveError("Attempted to move a child of a node with string-keyed descendants by index", path, move);
-		}
-		if (move.from > move.to) {
-			parentNode.splice(move.to, 0, ...parentNode.splice(move.from, 1));
-		} else { //We know that
-			parentNode.splice(move.to - 1, 0, ...parentNode.splice(move.from, 1));
-		}
-	} else {
-		if (Array.isArray(parentNode)) {
-			throw new MoveError("Attempted to move a child of a node with indexed descendants by string-key", path, move);
-		}
-		if (parentNode[move.to] !== undefined) {
-			throw new MoveError("Attempted to move a string-keyed child to the same key as another", path, move);
-		}
-	}
-}
-export function isNumericMove(move: {from: number, to: number}|{from: string, to: string}): move is {from: number, to: number} {
-	return typeof move.from === 'number' && typeof move.to === 'number';
-}
-
-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<{uuid: UUID}>|undefined): any {
-	const typedChildren = Array.isArray(definition?.children) ? definition.children : definition?.children?.[value?.type];
-	if (!typedChildren?.length) {
-		return value ?? buildDefaultValueFromDefinition(definition);
-	} else if (value === null || value === undefined) {
-		return buildDefaultValueFromDefinition(definition);
-	} else if (typeof value !== 'object') {
-		return value;
-	} else if (Array.isArray(value)) {
-		return value;
-	}
-	return {...value, ...Object.fromEntries(typedChildren.map(def => [def.name, populateValueBasedOnDefinition(value[def.name], def)]))};
-}
-
-export function walkToNode(root: DCNode, path: RawPath): DCNode {
-	let current = root;
-	for (let i = 0; i < path.length; i++) {
-		current = descendIntoDCNodeChild(current, path, i);
-	}
-	return current;
-}
-export function descendIntoDCNodeChild(current: DCNode|undefined, path: RawPath, i: number): DCNode {
-	if (current?.children === undefined) {
-		throw new PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathErrorType.UNEXPECTED_LEAF);
-	}
-	const pathNode = path[i];
-	if (typeof pathNode === 'string') {
-		if (Array.isArray(current.children)) {
-			throw new PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path, i);
-		}
-		current = current.children[pathNode];
-	} else if (pathNode === undefined) {
-		throw new PathError("Encountered an undefined name in a path.", path, i);
-	} else {
-		if (!Array.isArray(current.children)) {
-			throw new PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, i);
-		}
-		current = current.children[pathNode];
-	}
-	if (current === undefined) {
-		throw new PathError("Encountered a non-existent node while expecting one.", path, i, PathErrorType.UNEXPECTED_LEAF);
-	}
-	return current;
-}
-
-export function getDataStore(property: string, state: Draft<DCStoreState>, throwOnError: true): DataStore;
-export function getDataStore(property: string, state: Draft<DCStoreState>, throwOnError?: undefined|boolean|false): DataStore|undefined;
-export function getDataStore(property: string, state: Draft<DCStoreState>, throwOnError = true): DataStore|undefined {
-	let dataStore = state.dataStores.byProperty[property];
-	if (dataStore) {
-		return dataStore;
-	}
-	dataStore = state.dataStores.list.find(dataStore => dataStore.handlesProperty(property));
-	if (dataStore) {
-		console.warn(`Unable to locate the DataStore for ${property} via the byProperty map, but did find a DataStore that handles that property. This should not be possible.`);
-	} else if (throwOnError) {
-		throw new Error(`Unable to resolve the dataStore for ${property} on block ${state.blockClientId}`);
-	}
-	return dataStore;
-}
-
-export function getOptionalValue(path: NodePath, state: Draft<DCStoreState>) {
-	try {
-		return walkToNodeInValue(getDataStore(path[0], state, true).getValue(path[0]), path);
-	} catch (e) {
-		if (e instanceof PathError) {
-			return undefined;
-		}
-		throw e;
-	}
-}
-
-export function removeValueFromBackingDataStore(dataStore: DataStore, path: NodePath) {
-	const dsValue = dataStore.getValue(path[0]);
-	if (path.length === 1) {
-		dataStore.setValue(path[0], undefined);
-	} else {
-		dataStore.setValue(path[0], produce(dsValue, (dsValueDraft: any) => {
-			const nodeParent = walkToNodeInValue(dsValueDraft, path.slice(0, path.length - 1));
-			const nodeName = path[path.length - 1];
-			if (typeof nodeName === 'string') {
-				delete nodeParent[nodeName];
-			} else if (nodeName === undefined) {
-				throw new PathError("Encountered an undefined name in a path.", path);
-			} else {
-				(nodeParent as any[]).splice(nodeName, 1);
-			}
-		}));
-	}
-}
-export function writeValueToBackingDataStoreWithCorrections(path: NodePath, state: DCStoreState, value: any) {
-	if (typeof value === 'number' && Number.isNaN(value)) {
-		value = undefined; // This ensures that NaN's don't get stored
-	}
-	const rootDCNode = state.treeRoot.children[path[0]];
-	if (rootDCNode === undefined) {
-		throw new PathError("Encountered a path pointing to a non-existent root node.", path, 0);
-	}
-	const dataStore = getDataStore(path[0], state, true);
-
-	// This path both handles scalar values and ensures that the root "value" of Groups and Lists are initialized before writing the actual attribute
-	// 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);
-		if (rootDCNode.definition) {
-			doAction('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', writtenValue, rootDCNode.definition, dataStore);
-		}
-		if (path.length === 1) {
-			return;
-		}
-	}
-
-	let closestUsableDefinition = rootDCNode.definition;
-	let lastWrittenValue: unknown;
-	let didWriting = true;
-	dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsValueDraft: any) => {
-		let currentDSValue = dsValueDraft;
-		let currentDCNode = rootDCNode;
-		let parentCUD: DCNode['definition'] = undefined;
-		for (let i = 1; i < path.length - 1; i++) {
-			const nodeName = path[i];
-			currentDCNode = descendIntoDCNodeChild(currentDCNode, path, i);
-			if (typeof nodeName === 'string') {
-				//We only update the definition being used when we descend into a new node proper
-				parentCUD = closestUsableDefinition;
-				closestUsableDefinition = currentDCNode.definition;
-			} else if (nodeName === undefined) {
-				throw new PathError("Encountered an undefined name in a path.", path, i);
-			}
-
-			let nextDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
-			if (nextDSValue === undefined) {
-				lastWrittenValue = currentDSValue[nodeName] = buildDefaultValueFromDefinition(closestUsableDefinition);
-				currentDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
-				if (currentDSValue === undefined) {
-					if (parentCUD?.branching) {
-						didWriting = false;
-						return;
-					}
-					throw new PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathErrorType.UNEXPECTED_LEAF);
-				}
-			} else {
-				currentDSValue = nextDSValue;
-			}
-		}
-		const nodeName = path[path.length - 1];
-		if (nodeName === undefined) {
-			throw new PathError("Encountered an undefined name in a path.", path);
-		}
-		lastWrittenValue = currentDSValue[nodeName] = value;
-	}));
-	if (didWriting && closestUsableDefinition) {
-		doAction('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', lastWrittenValue, closestUsableDefinition, dataStore);
-	}
-}
-export function writeValueToBackingDataStore(dataStore: DataStore, path: NodePath, value: any) {
-	if (typeof value === 'number' && Number.isNaN(value)) {
-		value = undefined; // This ensures that NaN's don't get stored
-	}
-	const dsValue = dataStore.getValue(path[0]);
-	if (path.length === 1) {
-		dataStore.setValue(path[0], value);
-	} else {
-		dataStore.setValue(path[0], produce(dsValue, (dsValueDraft: any) => {
-			const nodeParent = walkToNodeInValue(dsValueDraft, path.slice(0, path.length - 1));
-			const nodeName = path[path.length - 1];
-			if (nodeName === undefined) {
-				throw new PathError("Encountered an undefined name in a path.", path);
-			}
-			nodeParent[nodeName] = value;
-		}));
-	}
-}
-
-/**
- * @param dsValue a value from a {@link DataStore}
- * @param path this is expected to be the entire path (including the node that was used to get {@link dsValue}
- */
-export function walkToNodeInValue(dsValue: any, path: RawPath) {
-	let current = dsValue;
-	for (let i = 1; i < path.length; i++) {
-		if (current === undefined) {
-			throw new PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathErrorType.UNEXPECTED_LEAF);
-		}
-		current = descendIntoDSValueNodeChild(current, path, i);
-	}
-	return current;
-}
-function descendIntoDSValueNodeChild(current: any, path: RawPath, i: number) {
-	const pathNode = path[i];
-	if (typeof pathNode === 'string') {
-		if (Array.isArray(current)) {
-			throw new PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path, i);
-		}
-		current = current[pathNode];
-	} else if (pathNode === undefined) {
-		throw new PathError("Encountered an undefined name in a path.", path, i);
-	} else {
-		if (!Array.isArray(current)) {
-			throw new PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, i);
-		}
-		current = current[pathNode];
-	}
-	return current;
-}
-
-export enum TreeMutatorResult {
-	STOP, CONTINUE, SKIP_DESCENDANTS
-}
-export function applyToTree(tree: DCNode, mutator: (node: DCNode, path: NodePath) => TreeMutatorResult, path: RawPath = []) {
-	if (tree.children === undefined) {
-		return TreeMutatorResult.CONTINUE;
-	}
-
-	const steps: Array<[NodePath, DCNode]> = Array.isArray(tree.children)
-		? tree.children.map((node, index) => [path.toSpliced(path.length, 0, index) as NodePath, node])
-		: Object.entries(tree.children).map(([name, node]) => [path.toSpliced(path.length, 0, name) as NodePath, node]);
-
-	for (const [nodePath, node] of steps) {
-		const mutatorRes = mutator(node, nodePath);
-		if (!mutatorRes) {
-			return TreeMutatorResult.STOP;
-		} else if (mutatorRes === TreeMutatorResult.CONTINUE) {
-			if (!applyToTree(node, mutator, nodePath)) {
-				return TreeMutatorResult.STOP;
-			}
-		}
-	}
-	return TreeMutatorResult.CONTINUE;
-}
-
-export type UUID = ReturnType<typeof crypto.randomUUID>;
-const cloneableDefaultValuesForNodes: Record<UUID, HydratedSimpleNativeProperty['default']> = {};
-export function recordCloneableDefaultValueForNode<T extends HydratedSimpleNativeProperty<{uuid?: UUID}>>(definition: T, overwriteExisting = false) {
-	if (!definition.uuid) {
-		definition.uuid = crypto.randomUUID();
-	}
-	if (overwriteExisting || !(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}>;
-}
-
-const recordedBackupValues: Record<UUID, any> = {};
-export function recordBackupForNode(node: DCNode, value: any) {
-	if (!node.backup) {
-		node.backup = crypto.randomUUID();
-	}
-	recordedBackupValues[node.backup] = value;
-}
-
-export function restoreValueFromPotentialBackup(node: DCNode) {
-	if (node.backup && node.backup in recordedBackupValues) {
-		const res = recordedBackupValues[node.backup];
-		delete recordedBackupValues[node.backup];
-		return res ?? buildDefaultValueFromDefinition(node.definition);
-	}
-	return buildDefaultValueFromDefinition(node.definition)
-}
-
-export function removeBackupForNode(node: DCNode) {
-	if (node.backup && node.backup in recordedBackupValues) {
-		delete recordedBackupValues[node.backup];
-	}
-}
-
-export function buildDefaultValueFromDefinition(definition: (HydratedSimpleNativeProperty<{uuid: UUID}>)|undefined, requireNonNullValueOnObject = true): any {
-	if (definition === undefined) {
-		return undefined;
-	} else if (definition.uuid in cloneableDefaultValuesForNodes) {
-		return structuredClone(cloneableDefaultValuesForNodes[definition.uuid]);
-	} else if (definition.default !== undefined) {
-		return structuredClone(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 {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
-			} else if (definition.type === 'object') {
-				if (Array.isArray(children)) {
-					return {
-						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 {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: {}};
-				}
-			}
-		} else if (typeof data === 'object') {
-			if (Array.isArray(data)) {
-				return {
-					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: [], validationError: ""};
-						}
-						return {
-							children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(item[def.name], def)])),
-							validationError: ""
-						};
-					})
-				};
-			} else {
-				const typedChildren = Array.isArray(children) ? children : children[data.type];
-				if (typedChildren === undefined) {
-					//TODO: We might need to throw an error here
-					return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "", children: []};
-				}
-				return {
-					condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: "",
-					children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(data[def.name], def)]))
-				};
-			}
-		}
-	}
-	return {condition: definition.condition, definition: recordCloneableDefaultValueForNode(definition), validationError: ""};
-}

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

@@ -1,50 +0,0 @@
-import type {DataController} from "./simple-native-property-api";
-
-export type DataControllerManager = {
-	addDataController(blockClientId: string, dataController: DataController): void,
-	getDataController(blockClientId: string): DataController|undefined,
-	removeDataController(blockClientId: string): void,
-	notifyOfValidationErrorStatusChange(blockClientId: string, hasValidationError: boolean): void
-}
-type DataControllerManagerInternals = DataControllerManager&{
-	dataControllers: Record<string, { dataController: DataController, hasValidationError: boolean }>,
-	styleSheetQueue?: Promise<CSSStyleSheet>
-	writeStyleInformation(): void
-}
-export function createDataControllerManager(): DataControllerManager {
-	// The add and remove methods for dataControllers don't sync up the style information. This is done deliberately to cut down on the number of CSS updates that we create.
-	return {
-		dataControllers: {},
-		addDataController(blockClientId, dataController) {
-			this.dataControllers[blockClientId] = {dataController, hasValidationError: false};
-		},
-		getDataController(blockClientId) {
-			return this.dataControllers[blockClientId]?.dataController;
-		},
-		removeDataController(blockClientId) {
-			delete this.dataControllers[blockClientId];
-		},
-		notifyOfValidationErrorStatusChange(blockClientId, hasValidationError) {
-			if (this.dataControllers[blockClientId] && this.dataControllers[blockClientId].hasValidationError !== hasValidationError) {
-				this.dataControllers[blockClientId].hasValidationError = hasValidationError;
-				this.writeStyleInformation();
-			}
-		},
-		async writeStyleInformation() {
-			if (this.styleSheetQueue === undefined) {
-				this.styleSheetQueue = new Promise(resolve => {
-					const styleSheet = new CSSStyleSheet();
-					document.adoptedStyleSheets.push(styleSheet);
-					resolve(styleSheet);
-				});
-			}
-			this.styleSheetQueue = this.styleSheetQueue.then(styleSheet => {
-				const blockMarkers = Object.entries(this.dataControllers)
-					.filter(([_, {hasValidationError}]) => hasValidationError).map(([blockClientId]) => blockClientId)
-					.map(blockClientId => `[data-block="${blockClientId}"]`)
-					.join(", ");
-				return styleSheet.replace(`.block-editor-list-view-tree tbody tr:is(${blockMarkers}) {background: var(--plaudit-gae-validation-error-bg) !important;}`);
-			});
-		}
-	} satisfies DataControllerManagerInternals as DataControllerManagerInternals;
-}