@plaudit/gutenberg-api-extensions 2.82.0 → 2.84.0

package/dist/blocks/data-controller.js

@@ -1,208 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkToNodeInValue = void 0;
 exports.useDataController = useDataController;
-exports.walkToNodeInValue = walkToNodeInValue;
 const element_1 = require("@wordpress/element");
-const hooks_1 = require("@wordpress/hooks");
 const toolkit_1 = require("@reduxjs/toolkit");
-const immer_1 = require("immer");
 const conditions_1 = require("./conditions");
-const MoveError_1 = require("./MoveError");
 const PathError_1 = require("./PathError");
-const simple_native_property_internal_shared_1 = require("./simple-native-property-internal-shared");
+const actions_1 = require("./data-controller/actions");
+const reducer_1 = require("./data-controller/reducer");
+const utils_1 = require("./data-controller/utils");
 function useDataController(blockClientId) {
     return (0, element_1.useMemo)(() => {
-        const initialState = {
-            treeRoot: { children: {}, rendered: true }, dataStores: { byProperty: {}, list: [] }, blockClientId, changedByManagedControl: false, rerenderTrigger: 0,
-            batchAddedPropertiesThatNeedWriteThrough: []
-        };
-        const store = (0, toolkit_1.configureStore)({
-            reducer(state = initialState, action) {
-                switch (action.type) {
-                    case "addProperties":
-                        return (0, immer_1.produce)(state, (draft) => {
-                            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 (0, immer_1.produce)(state, (draft) => performConditionChecks(draft, state, blockClientId));
-                    case "validateNodes":
-                        return (0, immer_1.produce)(state, (draft) => {
-                            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 (0, immer_1.produce)(state, (draft) => {
-                            draft.changedByManagedControl = false;
-                        });
-                    case "commitBatchAddedProperties":
-                        return (0, immer_1.produce)(state, (draft) => {
-                            draft.batchAddedPropertiesThatNeedWriteThrough = [];
-                            for (const batchAddedProperty of state.batchAddedPropertiesThatNeedWriteThrough) {
-                                const batchAddedPropertyState = state.treeRoot.children[batchAddedProperty.name];
-                                if (batchAddedPropertyState?.rendered) {
-                                    writeValueToBackingDataStoreWithCorrections([batchAddedProperty.name], state, (0, simple_native_property_internal_shared_1.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;
-                        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_1.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_1.PathError("Unable to locate the definition of the named node.", path);
-                            }
-                            const data = populateValueBasedOnDefinition(action.value, parentDefinition);
-                            const builtNode = buildNodeFromDataAndDefinition(data, definition);
-                            return (0, immer_1.produce)(state, (draft) => {
-                                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_1.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_1.PathError("Encountered an undefined name in a path.", path);
-                        }
-                        else {
-                            const data = populateValueBasedOnDefinition(action.value, parentDefinition);
-                            const builtNode = buildNodeFromDataAndDefinition(data, parentDefinition);
-                            return (0, immer_1.produce)(state, (draft) => {
-                                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_1.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 (0, immer_1.produce)(state, (draft) => {
-                            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 (0, immer_1.produce)(state, (draft) => {
-                            draft.changedByManagedControl = true;
-                            moveNodeWithinParent(walkToNode(draft.treeRoot, path).children, path, action);
-                            const dataStore = getDataStore(path[0], state);
-                            dataStore.setValue(path[0], (0, immer_1.produce)(dataStore.getValue(path[0]), (dsDraft) => {
-                                moveNodeWithinParent(walkToNodeInValue(dsDraft, path), path, action);
-                            }));
-                            if (!action.inBatch) {
-                                performConditionChecks(draft, state, blockClientId);
-                            }
-                        });
-                    case "validateNode":
-                        return (0, immer_1.produce)(state, (draft) => validateNode(path, draft));
-                    case "writeValue":
-                        writeValueToBackingDataStoreWithCorrections(path, state, action.value);
-                        if (!action.inBatch) {
-                            return (0, immer_1.produce)(state, (draft) => {
-                                draft.changedByManagedControl = true;
-                                validateNode(path, draft);
-                                performConditionChecks(draft, state, blockClientId);
-                            });
-                        }
-                        return state;
-                }
-                return state; // This accounts for WordPress' meta actions
-            }
-        });
+        const reducer = (0, reducer_1.buildReducer)(blockClientId);
+        const store = (0, toolkit_1.configureStore)({ reducer });
         function getDataStoreImpl(property, required) {
-            return required ? getDataStore(property, store.getState(), true) : getDataStore(property, store.getState(), false);
+            return required ? (0, utils_1.getDataStore)(property, store.getState(), true) : (0, utils_1.getDataStore)(property, store.getState(), false);
         }
         const dataController = {
-            dispatch(action) {
-                return store.dispatch(action);
-            },
             getDataStore: getDataStoreImpl,
             getAllDataStores() {
                 return store.getState().dataStores.list;
@@ -211,33 +25,36 @@ function useDataController(blockClientId) {
                 return propertyPath => (0, conditions_1.resolveValueForCondition)(propertyPath, contextPath, blockClientId, getDataStoreImpl);
             },
             getValue(path) {
-                return getOptionalValue(path, store.getState());
+                return (0, utils_1.getOptionalValue)(path, store.getState());
             },
             setValue(path, value) {
-                store.dispatch({ type: "writeValue", path, value });
+                store.dispatch(actions_1.actions.node.write({ path, value }));
             },
             addProperties(properties, dataStore, inBatch) {
-                store.dispatch({ type: "addProperties", properties, dataStore, inBatch });
+                store.dispatch(actions_1.actions.addProperties({ properties, dataStore }, inBatch));
             },
             addNode(path, value) {
                 try {
-                    store.dispatch({ type: "addNode", path, value });
+                    store.dispatch(actions_1.actions.node.add({ path, value }));
                 }
                 catch (e) {
                     if (e instanceof PathError_1.PathError && e.errorType === PathError_1.PathErrorType.UNEXPECTED_LEAF) {
                         for (let i = e.errorIndex; i < path.length - 1; i++) {
-                            store.dispatch({ type: "addNode", path: path.slice(0, i), inBatch: true });
+                            store.dispatch(actions_1.actions.node.add({ path: path.slice(0, i), value }, true));
                         }
-                        store.dispatch({ type: "addNode", path, value });
+                        store.dispatch(actions_1.actions.node.add({ path, value }));
                     }
                     throw e;
                 }
             },
             removeNode(path) {
-                store.dispatch({ type: "removeNode", path });
+                store.dispatch(actions_1.actions.node.remove({ path }));
             },
             moveNode(path, indices) {
-                store.dispatch({ type: "moveNode", path, ...indices });
+                store.dispatch(actions_1.actions.node.move({ path, ...indices }));
+            },
+            validateNode(path) {
+                store.dispatch(actions_1.actions.node.validate({ path }));
             },
             hasRenderedNode(properties) {
                 const rootNodes = store.getState().treeRoot.children;
@@ -275,36 +92,34 @@ function useDataController(blockClientId) {
                 return false;
             },
             getIsRendered(path) {
-                return walkToNode(store.getState().treeRoot, path).rendered ?? true;
+                return (0, utils_1.walkToNode)(store.getState().treeRoot, path).rendered ?? true;
             },
             getNode(path) {
-                return walkToNode(store.getState().treeRoot, path);
+                return (0, utils_1.walkToNode)(store.getState().treeRoot, path);
             },
             getValidationError(path) {
-                return walkToNode(store.getState().treeRoot, path).validationError;
+                return (0, utils_1.walkToNode)(store.getState().treeRoot, path).validationError;
             },
             getWasChangedByManagedControl() {
                 return store.getState().changedByManagedControl;
             },
             markManagedControlChangeHandled() {
-                store.dispatch({ type: "markManagedControlChangeHandled" });
+                store.dispatch(actions_1.actions.markManagedControlChangeHandled({}));
+            },
+            checkConditions() {
+                store.dispatch(actions_1.actions.checkConditions({}));
+            },
+            validateNodes() {
+                store.dispatch(actions_1.actions.validateNodes({}));
+            },
+            commitBatchAddedProperties() {
+                store.dispatch(actions_1.actions.commitBatchAddedProperties({}));
             },
             blockClientId
         };
         return dataController;
     }, [blockClientId]);
 }
-function getOptionalValue(path, state) {
-    try {
-        return walkToNodeInValue(getDataStore(path[0], state).getValue(path[0]), path);
-    }
-    catch (e) {
-        if (e instanceof PathError_1.PathError) {
-            return undefined;
-        }
-        throw e;
-    }
-}
 function testForValidationErrors(node) {
     if (!node || !node.rendered) {
         return false;
@@ -328,392 +143,6 @@ function testForValidationErrors(node) {
     }
     return false;
 }
-function validateNode(path, draft) {
-    if (validateFoundNode(walkToNode(draft.treeRoot, path), path, draft)) {
-        draft.rerenderTrigger = draft.rerenderTrigger + 1;
-    }
-}
-function removeFromParentNode(parentNode, path) {
-    if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
-        throw new PathError_1.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_1.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_1.PathError("Encountered an undefined name in a path.", path);
-    }
-    else {
-        if (!Array.isArray(parentNode)) {
-            throw new PathError_1.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, path, move) {
-    if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
-        throw new PathError_1.PathError("Encountered a non-existent node while expecting one.", path);
-    }
-    if (isNumericMove(move)) {
-        if (!Array.isArray(parentNode)) {
-            throw new MoveError_1.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_1.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_1.MoveError("Attempted to move a string-keyed child to the same key as another", path, move);
-        }
-    }
-}
-function isNumericMove(move) {
-    return typeof move.from === 'number' && typeof move.to === 'number';
-}
-function resolveParentNodeDefinition(root, path) {
-    if (path.length < 2) {
-        throw new PathError_1.PathError("Unable to get the parent node of a path with less than two nodes", path, path.length - 1, PathError_1.PathErrorType.INSUFFICIENT_LENGTH);
-    }
-    return walkToNode(root, path.slice(0, path.length - (typeof path[path.length - 2] === 'number' ? 2 : 1))).definition;
-}
-function populateValueBasedOnDefinition(value, definition) {
-    const typedChildren = Array.isArray(definition?.children) ? definition.children : definition?.children?.[value?.type];
-    if (!typedChildren?.length) {
-        return value ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(definition);
-    }
-    else if (value === null || value === undefined) {
-        return (0, simple_native_property_internal_shared_1.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, path) {
-    let current = root;
-    for (let i = 0; i < path.length; i++) {
-        current = descendIntoDCNodeChild(current, path, i);
-    }
-    return current;
-}
-function descendIntoDCNodeChild(current, path, i) {
-    if (current?.children === undefined) {
-        throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
-    }
-    const pathNode = path[i];
-    if (typeof pathNode === 'string') {
-        if (Array.isArray(current.children)) {
-            throw new PathError_1.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_1.PathError("Encountered an undefined name in a path.", path, i);
-    }
-    else {
-        if (!Array.isArray(current.children)) {
-            throw new PathError_1.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_1.PathError("Encountered a non-existent node while expecting one.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
-    }
-    return current;
-}
-function performConditionChecks(draft, state, blockClientId) {
-    const propertyValueResolverBuilder = path => propertyPath => (0, conditions_1.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 = (0, conditions_1.testCondition)(condition, propertyValueResolverBuilder(path));
-            if (newRendered !== node.rendered) {
-                const dataStore = getDataStore(path[0], state);
-                let currentValue;
-                try {
-                    currentValue = walkToNodeInValue(dataStore.getValue(path[0]), path);
-                }
-                catch (e) {
-                    if (!(e instanceof PathError_1.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 ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(stateNode.definition));
-                }
-                node.rendered = newRendered;
-            }
-            return node.rendered ? TreeMutatorResult.CONTINUE : TreeMutatorResult.SKIP_DESCENDANTS;
-        }
-    });
-}
-/**
- * @return true iff the validation state changed
- */
-function validateFoundNode(node, path, draft) {
-    const definition = node.definition;
-    if (definition) {
-        let validationError;
-        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, state, throwOnError = true) {
-    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, path) {
-    const dsValue = dataStore.getValue(path[0]);
-    if (path.length === 1) {
-        dataStore.setValue(path[0], undefined);
-    }
-    else {
-        dataStore.setValue(path[0], (0, immer_1.produce)(dsValue, (dsValueDraft) => {
-            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_1.PathError("Encountered an undefined name in a path.", path);
-            }
-            else {
-                nodeParent.splice(nodeName, 1);
-            }
-        }));
-    }
-}
-function writeValueToBackingDataStoreWithCorrections(path, state, value) {
-    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_1.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 ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(rootDCNode.definition, path.length === 1);
-        dataStore.setValue(path[0], writtenValue);
-        if (rootDCNode.definition) {
-            (0, hooks_1.doAction)('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', writtenValue, rootDCNode.definition, dataStore);
-        }
-        if (path.length === 1) {
-            return;
-        }
-    }
-    let closestUsableDefinition = rootDCNode.definition;
-    let lastWrittenValue;
-    dataStore.setValue(path[0], (0, immer_1.produce)(dataStore.getValue(path[0]), (dsValueDraft) => {
-        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_1.PathError("Encountered an undefined name in a path.", path, i);
-            }
-            let nextDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
-            if (nextDSValue === undefined) {
-                lastWrittenValue = currentDSValue[nodeName] = (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(closestUsableDefinition);
-                currentDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
-                if (currentDSValue === undefined) {
-                    throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
-                }
-            }
-            else {
-                currentDSValue = nextDSValue;
-            }
-        }
-        const nodeName = path[path.length - 1];
-        if (nodeName === undefined) {
-            throw new PathError_1.PathError("Encountered an undefined name in a path.", path);
-        }
-        lastWrittenValue = currentDSValue[nodeName] = value;
-    }));
-    if (closestUsableDefinition) {
-        (0, hooks_1.doAction)('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', lastWrittenValue, closestUsableDefinition, dataStore);
-    }
-}
-function writeValueToBackingDataStore(dataStore, path, value) {
-    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], (0, immer_1.produce)(dsValue, (dsValueDraft) => {
-            const nodeParent = walkToNodeInValue(dsValueDraft, path.slice(0, path.length - 1));
-            const nodeName = path[path.length - 1];
-            if (nodeName === undefined) {
-                throw new PathError_1.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}
- */
-function walkToNodeInValue(dsValue, path) {
-    let current = dsValue;
-    for (let i = 1; i < path.length; i++) {
-        if (current === undefined) {
-            throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
-        }
-        current = descendIntoDSValueNodeChild(current, path, i);
-    }
-    return current;
-}
-function descendIntoDSValueNodeChild(current, path, i) {
-    const pathNode = path[i];
-    if (typeof pathNode === 'string') {
-        if (Array.isArray(current)) {
-            throw new PathError_1.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_1.PathError("Encountered an undefined name in a path.", path, i);
-    }
-    else {
-        if (!Array.isArray(current)) {
-            throw new PathError_1.PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, i);
-        }
-        current = current[pathNode];
-    }
-    return current;
-}
-var TreeMutatorResult;
-(function (TreeMutatorResult) {
-    TreeMutatorResult[TreeMutatorResult["STOP"] = 0] = "STOP";
-    TreeMutatorResult[TreeMutatorResult["CONTINUE"] = 1] = "CONTINUE";
-    TreeMutatorResult[TreeMutatorResult["SKIP_DESCENDANTS"] = 2] = "SKIP_DESCENDANTS";
-})(TreeMutatorResult || (TreeMutatorResult = {}));
-function applyToTree(tree, mutator, path = []) {
-    if (tree.children === undefined) {
-        return TreeMutatorResult.CONTINUE;
-    }
-    const steps = Array.isArray(tree.children)
-        ? tree.children.map((node, index) => [path.toSpliced(path.length, 0, index), node])
-        : Object.entries(tree.children).map(([name, node]) => [path.toSpliced(path.length, 0, name), 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, definition) {
-    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: "" };
-}
+var utils_2 = require("./data-controller/utils");
+Object.defineProperty(exports, "walkToNodeInValue", { enumerable: true, get: function () { return utils_2.walkToNodeInValue; } });
 //# sourceMappingURL=data-controller.js.map