@plaudit/gutenberg-api-extensions 2.82.0 → 2.84.0

package/src/blocks/data-controller.ts

@@ -1,16 +1,19 @@
 import {useMemo} from "@wordpress/element";
-import {doAction} from "@wordpress/hooks";
 
-import {configureStore} from "@reduxjs/toolkit";
+import {configureStore, Middleware, Tuple} from "@reduxjs/toolkit";
 
-import {produce} from "immer";
+import type {Dispatch} from "redux";
+import type {ThunkDispatch} from "redux-thunk";
 
-import {type Condition, resolveValueForCondition, testCondition} from "./conditions";
-import type {WordPressMetaActions} from "../lib/useful-types";
-import {MoveError} from "./MoveError";
+import {type Condition, resolveValueForCondition} from "./conditions";
 import {PathError, PathErrorType} from "./PathError";
-import type {DataController, DataStore, HydratedSimpleNativeProperty, NodePath, RawPath} from "./simple-native-property-api";
-import {buildDefaultValueFromDefinition, type HydratedLaidOutProperties} from "./simple-native-property-internal-shared";
+import type {DataController, DataStore, HydratedSimpleNativeProperty, NodePath} from "./simple-native-property-api";
+
+import {actions, 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";
 
 type DescendantsWrapper = {[key: string]: DCNode}|DCNode[];
 export type DCNode = {
@@ -22,213 +25,25 @@ export type DCNode = {
 	validationError?: string
 };
 export type DCStoreState = {
-	treeRoot: DCNode&{children: {[key: string]: DCNode}}, dataStores: {byProperty: {[key: string]: DataStore}, list: DataStore[]}, blockClientId: string,
+	treeRoot: Omit<DCNode, 'children'>&{children: {[key: string]: DCNode}},
+	dataStores: {byProperty: {[key: string]: DataStore}, list: DataStore[]},
+	blockClientId: string,
 	changedByManagedControl: boolean,
 	rerenderTrigger: number,
 	batchAddedPropertiesThatNeedWriteThrough: HydratedSimpleNativeProperty[]
 };
-
-type GlobalDCAction<T extends string, P extends {[key: Exclude<string, 'type'|'inBatch'>]: any} = {}> = {type: T, inBatch?: boolean}&P;
-type DCAction<T extends string, P extends {[key: Exclude<string, 'type'|'path'|'inBatch'>]: any} = {}> = {type: T, path: NodePath, inBatch?: boolean}&P;
-export type DataControllerActions = DCAction<"writeValue", {value?: any}>|DCAction<"validateNode">|GlobalDCAction<"validateNodes">|GlobalDCAction<"checkConditions">
-	|DCAction<"addNode", {value?: any, subtype?: string}>|DCAction<"removeNode">|DCAction<"moveNode", {from: number, to: number}|{from: string, to: string}>
-	|GlobalDCAction<"addProperties", {properties: HydratedLaidOutProperties, dataStore: DataStore}>|GlobalDCAction<"markManagedControlChangeHandled">
-	|GlobalDCAction<"commitBatchAddedProperties">;
+type DCThunkDispatch = ThunkDispatch<DCStoreState, unknown, DataControllerActions>;
 
 export function useDataController(blockClientId: string): DataController {
 	return useMemo(() => {
-		const initialState: DCStoreState = {
-			treeRoot: {children: {}, rendered: true}, dataStores: {byProperty: {}, list: []}, blockClientId, changedByManagedControl: false, rerenderTrigger: 0,
-			batchAddedPropertiesThatNeedWriteThrough: []
-		};
-
-		const store = configureStore<DCStoreState, DataControllerActions|WordPressMetaActions, []>({
-			reducer(state = initialState, action) {
-				switch (action.type) {
-					case "addProperties":
-						return produce(state, (draft: typeof state) => {
-							draft.changedByManagedControl = true;
-							if (!draft.dataStores.list.includes(action.dataStore)) {
-								draft.dataStores.list.push(action.dataStore);
-							}
-							for (const property of action.properties) {
-								if (Array.isArray(property)) {
-									for (const prop of property) {
-										if (action.dataStore.getValue(prop.name) === undefined && action.inBatch) {
-											draft.batchAddedPropertiesThatNeedWriteThrough.push(prop);
-										}
-										action.dataStore.addProperty(prop, !action.inBatch);
-										draft.dataStores.byProperty[prop.name] = action.dataStore;
-										draft.treeRoot.children[prop.name] = buildNodeFromDataAndDefinition(action.dataStore.getValue(prop.name), prop);
-									}
-								} else {
-									if (action.dataStore.getValue(property.name) === undefined && action.inBatch) {
-										draft.batchAddedPropertiesThatNeedWriteThrough.push(property);
-									}
-									action.dataStore.addProperty(property, !action.inBatch);
-									draft.dataStores.byProperty[property.name] = action.dataStore;
-									draft.treeRoot.children[property.name] = buildNodeFromDataAndDefinition(action.dataStore.getValue(property.name), property);
-								}
-							}
-							if (!action.inBatch) {
-								performConditionChecks(draft, state, blockClientId);
-							}
-						});
-					case "checkConditions":
-						return produce(state, (draft: typeof state) => performConditionChecks(draft, state, blockClientId));
-					case "validateNodes":
-						return produce(state, (draft: typeof state) => {
-							let hasChanged = false;
-							applyToTree(draft.treeRoot, (node, path) => {
-								if (!node.rendered) {
-									return TreeMutatorResult.SKIP_DESCENDANTS;
-								}
-
-								if (validateFoundNode(node, path, draft)) {
-									hasChanged = true;
-								}
-								return TreeMutatorResult.CONTINUE;
-							});
-							if (hasChanged) {
-								draft.rerenderTrigger = state.rerenderTrigger + 1;
-							}
-						});
-					case "markManagedControlChangeHandled":
-						return produce(state, (draft: typeof state) => {
-							draft.changedByManagedControl = false;
-						});
-					case "commitBatchAddedProperties":
-						return produce(state, (draft: typeof state) => {
-							draft.batchAddedPropertiesThatNeedWriteThrough = [];
-							for (const batchAddedProperty of state.batchAddedPropertiesThatNeedWriteThrough) {
-								const batchAddedPropertyState = state.treeRoot.children[batchAddedProperty.name];
-								if (batchAddedPropertyState?.rendered) {
-									writeValueToBackingDataStoreWithCorrections([batchAddedProperty.name], state, buildDefaultValueFromDefinition(batchAddedProperty));
-								}
-							}
-						});
-				}
-
-				if (!('path' in action)) {
-					return state; // This accounts for WordPress' meta actions
-				}
-				const {path, type} = action;
-				switch (type) {
-					case "addNode":
-						const parentDefinition = resolveParentNodeDefinition(state.treeRoot, path);
-						if (!parentDefinition) {
-							throw new Error("Cannot add children to a node without a definition");
-						}
-						const nodeNameOrIndex = path[path.length - 1];
-						let parentDefinitionChildren: HydratedSimpleNativeProperty[]|undefined;
-						if (Array.isArray(parentDefinition.children) || parentDefinition.children === undefined) {
-							parentDefinitionChildren = parentDefinition.children;
-						} else {
-							const subtype = action.value?.type ?? action.subtype;
-							if (!subtype || !parentDefinition.children[subtype]) {
-								throw new PathError("Unable to locate the definition of the named node because its type could not be resolved.", path);
-							}
-							parentDefinitionChildren = parentDefinition.children[subtype];
-						}
-
-						if (typeof nodeNameOrIndex === 'string') {
-							const definition = parentDefinitionChildren?.find(definition => definition.name === nodeNameOrIndex);
-							if (definition === undefined) {
-								throw new PathError("Unable to locate the definition of the named node.", path);
-							}
-							const data = populateValueBasedOnDefinition(action.value, parentDefinition);
-							const builtNode = buildNodeFromDataAndDefinition(data, definition);
-							return produce(state, (draft: typeof state) => {
-								draft.changedByManagedControl = true;
-								const parentNode = walkToNode(draft.treeRoot, path.slice(0, path.length - 1));
-								if (parentNode.children === undefined) {
-									parentNode.children = {[nodeNameOrIndex]: builtNode};
-								} else {
-									if (Array.isArray(parentNode.children)) {
-										throw new PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path);
-									}
-									parentNode.children[nodeNameOrIndex] = builtNode;
-								}
-								writeValueToBackingDataStoreWithCorrections(path, state, data);
-								if (!action.inBatch) {
-									performConditionChecks(draft, state, blockClientId);
-								}
-							});
-						} else if (nodeNameOrIndex === undefined) {
-							throw new PathError("Encountered an undefined name in a path.", path);
-						} else {
-							const data = populateValueBasedOnDefinition(action.value, parentDefinition);
-							const builtNode = buildNodeFromDataAndDefinition(data, parentDefinition);
-							return produce(state, (draft: typeof state) => {
-								draft.changedByManagedControl = true;
-								const parentNode = walkToNode(draft.treeRoot, path.slice(0, path.length - 1));
-								if (parentNode.children === undefined) {
-									parentNode.children = [];
-									parentNode.children[nodeNameOrIndex] = builtNode;
-								} else {
-									if (!Array.isArray(parentNode.children)) {
-										throw new PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path);
-									}
-									parentNode.children[nodeNameOrIndex] = builtNode;
-								}
-								writeValueToBackingDataStoreWithCorrections(path, state, data);
-								if (!action.inBatch) {
-									performConditionChecks(draft, state, blockClientId);
-								}
-							});
-						}
-					case "removeNode":
-						return produce(state, (draft: typeof state) => {
-							draft.changedByManagedControl = true;
-							const parentNode = walkToNode(draft.treeRoot, path.slice(0, path.length - 1));
-							removeFromParentNode(parentNode.children, path);
-							removeValueFromBackingDataStore(getDataStore(path[0], state), path);
-							if (!action.inBatch) {
-								performConditionChecks(draft, state, blockClientId);
-							}
-						});
-					case "moveNode":
-						// If from and to are the same, then this is a no-op, so we can just skip it
-						if (action.from === action.to) {
-							return state;
-						}
-						return produce(state, (draft: typeof state) => {
-							draft.changedByManagedControl = true;
-							moveNodeWithinParent(walkToNode(draft.treeRoot, path).children, path, action);
-							const dataStore = getDataStore(path[0], state);
-							dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsDraft: any) => {
-								moveNodeWithinParent(walkToNodeInValue(dsDraft, path), path, action);
-							}));
-							if (!action.inBatch) {
-								performConditionChecks(draft, state, blockClientId);
-							}
-						});
-					case "validateNode":
-						return produce(state, (draft: typeof state) => validateNode(path, draft));
-					case "writeValue":
-						writeValueToBackingDataStoreWithCorrections(path, state, action.value);
-						if (!action.inBatch) {
-							return produce(state, (draft: typeof state) => {
-								draft.changedByManagedControl = true;
-								validateNode(path, draft);
-								performConditionChecks(draft, state, blockClientId);
-							});
-						}
-						return state;
-				}
-				return state; // This accounts for WordPress' meta actions
-			}
-		});
-
+		const reducer = buildReducer(blockClientId);
+		const store = configureStore<DCStoreState, DataControllerActions, Tuple<ReadonlyArray<Middleware<{}, DCStoreState, Dispatch<DataControllerActions>>>>>({reducer});
 		function getDataStoreImpl(property: string, required: true): DataStore;
 		function getDataStoreImpl(property: string, required?: undefined|false): DataStore|undefined;
 		function getDataStoreImpl(property: string, required?: boolean): DataStore|undefined {
 			return required ? getDataStore(property, store.getState(), true) : getDataStore(property, store.getState(), false);
 		}
 		const dataController: DataController = {
-			dispatch(action) {
-				return store.dispatch(action);
-			},
 			getDataStore: getDataStoreImpl,
 			getAllDataStores() {
 				return store.getState().dataStores.list;
@@ -240,29 +55,32 @@ export function useDataController(blockClientId: string): DataController {
 				return getOptionalValue(path, store.getState());
 			},
 			setValue(path, value) {
-				store.dispatch({type: "writeValue", path, value});
+				store.dispatch(actions.node.write({path, value}));
 			},
 			addProperties(properties, dataStore, inBatch) {
-				store.dispatch({type: "addProperties", properties, dataStore, inBatch});
+				store.dispatch(actions.addProperties({properties, dataStore}, inBatch));
 			},
 			addNode(path, value) {
 				try {
-					store.dispatch({type: "addNode", path, value});
+					store.dispatch(actions.node.add({path, value}));
 				} catch (e) {
 					if (e instanceof PathError && e.errorType === PathErrorType.UNEXPECTED_LEAF) {
 						for (let i = e.errorIndex; i < path.length - 1; i++) {
-							store.dispatch({type: "addNode", path: path.slice(0, i) as NodePath, inBatch: true});
+							store.dispatch(actions.node.add({path: path.slice(0, i) as NodePath, value}, true));
 						}
-						store.dispatch({type: "addNode", path, value});
+						store.dispatch(actions.node.add({path, value}));
 					}
 					throw e;
 				}
 			},
 			removeNode(path) {
-				store.dispatch({type: "removeNode", path});
+				store.dispatch(actions.node.remove({path}));
 			},
 			moveNode(path, indices) {
-				store.dispatch({type: "moveNode", path, ...indices});
+				store.dispatch(actions.node.move({path, ...indices}));
+			},
+			validateNode(path) {
+				store.dispatch(actions.node.validate({path}));
 			},
 			hasRenderedNode(properties) {
 				const rootNodes = store.getState().treeRoot.children;
@@ -310,7 +128,16 @@ export function useDataController(blockClientId: string): DataController {
 				return store.getState().changedByManagedControl;
 			},
 			markManagedControlChangeHandled() {
-				store.dispatch({type: "markManagedControlChangeHandled"});
+				store.dispatch(actions.markManagedControlChangeHandled({}));
+			},
+			checkConditions() {
+				store.dispatch(actions.checkConditions({}));
+			},
+			validateNodes() {
+				store.dispatch(actions.validateNodes({}));
+			},
+			commitBatchAddedProperties() {
+				store.dispatch(actions.commitBatchAddedProperties({}));
 			},
 			blockClientId
 		};
@@ -318,17 +145,6 @@ export function useDataController(blockClientId: string): DataController {
 	}, [blockClientId]);
 }
 
-function getOptionalValue(path: NodePath, state: DCStoreState) {
-	try {
-		return walkToNodeInValue(getDataStore(path[0], state).getValue(path[0]), path);
-	} catch (e) {
-		if (e instanceof PathError) {
-			return undefined;
-		}
-		throw e;
-	}
-}
-
 function testForValidationErrors(node: DCNode|undefined) {
 	if (!node || !node.rendered) {
 		return false;
@@ -350,387 +166,4 @@ function testForValidationErrors(node: DCNode|undefined) {
 	return false;
 }
 
-function validateNode(path: NodePath, draft: DCStoreState) {
-	if (validateFoundNode(walkToNode(draft.treeRoot, path), path, draft)) {
-		draft.rerenderTrigger = draft.rerenderTrigger + 1;
-	}
-}
-
-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);
-	}
-}
-
-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);
-		}
-	}
-}
-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';
-}
-
-function resolveParentNodeDefinition(root: DCNode, path: RawPath): HydratedSimpleNativeProperty|undefined {
-	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;
-}
-
-function populateValueBasedOnDefinition(value: any, definition: HydratedSimpleNativeProperty|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)]))};
-}
-
-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;
-}
-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;
-}
-
-type PropertyValueResolverBuilder = (path: RawPath) => (propertyPath: RawPath) => any;
-function performConditionChecks(draft: DCStoreState, state: DCStoreState, blockClientId: string) {
-	const propertyValueResolverBuilder: PropertyValueResolverBuilder =
-		path => propertyPath => resolveValueForCondition(propertyPath, path, blockClientId,
-			property => getDataStore(property, draft, false));
-	applyToTree(draft.treeRoot, (node, path) => {
-		const condition = node.condition;
-		if (condition === undefined) {
-			node.rendered = true;
-			return TreeMutatorResult.CONTINUE;
-		} else {
-			const newRendered = testCondition(condition, propertyValueResolverBuilder(path));
-			if (newRendered !== node.rendered) {
-				const dataStore = getDataStore(path[0], state);
-				let currentValue: any;
-				try {
-					currentValue = walkToNodeInValue(dataStore.getValue(path[0]), path);
-				} catch (e) {
-					if (!(e instanceof PathError)) {
-						throw e;
-					}
-					currentValue = undefined;
-				}
-				if (!newRendered) {
-					// Create a backup if we are transitioning from rendered -> unrendered
-					node.backup = 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, stateNode.backup ?? buildDefaultValueFromDefinition(stateNode.definition));
-				}
-				node.rendered = newRendered;
-			}
-			return node.rendered ? TreeMutatorResult.CONTINUE : TreeMutatorResult.SKIP_DESCENDANTS;
-		}
-	});
-}
-
-/**
- * @return true iff the validation state changed
- */
-function validateFoundNode(node: DCNode, path: NodePath, 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;
-}
-
-function getDataStore(property: string, state: DCStoreState, throwOnError: false): DataStore|undefined;
-function getDataStore(property: string, state: DCStoreState, throwOnError?: undefined|true): DataStore;
-function getDataStore(property: string, state: 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;
-}
-
-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);
-			}
-		}));
-	}
-}
-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);
-
-	// 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
-	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;
-	dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsValueDraft: any) => {
-		let currentDSValue = dsValueDraft;
-		let currentDCNode = rootDCNode;
-		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
-				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) {
-					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 (closestUsableDefinition) {
-		doAction('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', lastWrittenValue, closestUsableDefinition, dataStore);
-	}
-}
-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;
-}
-
-enum TreeMutatorResult {
-	STOP, CONTINUE, SKIP_DESCENDANTS
-}
-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;
-}
-
-function buildNodeFromDataAndDefinition(data: any, definition: HydratedSimpleNativeProperty): 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: []};
-			} else if (definition.type === 'object') {
-				if (Array.isArray(children)) {
-					return {
-						rendered: true, condition: definition.condition, 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: {}};
-				}
-			}
-		} else if (typeof data === 'object') {
-			if (Array.isArray(data)) {
-				return {
-					rendered: true, condition: definition.condition, 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: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(item[def.name], def)])),
-							rendered: true, validationError: ""
-						};
-					})
-				};
-			} else {
-				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, validationError: "",
-					children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(data[def.name], def)]))
-				};
-			}
-		}
-	}
-	return {rendered: true, condition: definition.condition, definition, validationError: ""};
-}
+export {walkToNodeInValue} from "./data-controller/utils";