@plaudit/gutenberg-api-extensions 2.43.2 → 2.44.1

package/build/blocks/data-controller.js

@@ -0,0 +1,641 @@
+import { useMemo } from "@wordpress/element";
+import { configureStore } from "@reduxjs/toolkit";
+import { produce } from "immer";
+import { resolveValueForCondition, testCondition } from "./conditions";
+import { MoveError } from "./MoveError";
+import { PathError, PathErrorType } from "./PathError";
+export function useDataController(blockClientId) {
+    return useMemo(() => {
+        const initialState = { treeRoot: { children: {}, rendered: true }, dataStores: { byProperty: {}, list: [] }, blockClientId };
+        const store = configureStore({
+            reducer(state = initialState, action) {
+                switch (action.type) {
+                    case "addProperties":
+                        return produce(state, (draft) => {
+                            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) {
+                                        draft.dataStores.byProperty[prop.name] = action.dataStore;
+                                        draft.treeRoot.children[prop.name] = buildNodeFromDataAndDefinition(action.dataStore.getValue(prop.name), prop);
+                                    }
+                                }
+                                else {
+                                    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) => performConditionChecks(draft, state, blockClientId));
+                    case "validateNodes":
+                        return produce(state, (draft) => {
+                            applyToTree(draft.treeRoot, (node, path) => {
+                                if (!node.rendered) {
+                                    return TreeMutatorResult.SKIP_DESCENDANTS;
+                                }
+                                validateFoundNode(node, path, draft);
+                                return TreeMutatorResult.CONTINUE;
+                            });
+                        });
+                }
+                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 nodeName = path[path.length - 1];
+                        if (typeof nodeName === 'string') {
+                            const definition = parentDefinition.children?.find(definition => definition.name === nodeName);
+                            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) => {
+                                const parentNode = walkToNode(draft.treeRoot, path.slice(0, path.length - 1));
+                                if (parentNode.children === undefined) {
+                                    parentNode.children = { [nodeName]: 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[nodeName] = builtNode;
+                                }
+                                writeValueToBackingDataStoreWithCorrections(path, state, data);
+                                if (!action.inBatch) {
+                                    performConditionChecks(draft, state, blockClientId);
+                                }
+                            });
+                        }
+                        else if (nodeName === 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) => {
+                                const parentNode = walkToNode(draft.treeRoot, path.slice(0, path.length - 1));
+                                if (parentNode.children === undefined) {
+                                    parentNode.children = [];
+                                    parentNode.children[nodeName] = 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[nodeName] = builtNode;
+                                }
+                                writeValueToBackingDataStoreWithCorrections(path, state, data);
+                                if (!action.inBatch) {
+                                    performConditionChecks(draft, state, blockClientId);
+                                }
+                            });
+                        }
+                    case "removeNode":
+                        return produce(state, (draft) => {
+                            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) => {
+                            moveNodeWithinParent(walkToNode(draft.treeRoot, path).children, path, action);
+                            const dataStore = getDataStore(path[0], state);
+                            dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsDraft) => {
+                                moveNodeWithinParent(walkToNodeInValue(dsDraft, path), path, action);
+                            }));
+                            if (!action.inBatch) {
+                                performConditionChecks(draft, state, blockClientId);
+                            }
+                        });
+                    case "validateNode":
+                        return produce(state, (draft) => validateNode(path, draft)); //TODO: Write something to the block metadata on validation change to force an update
+                    case "writeValue":
+                        writeValueToBackingDataStoreWithCorrections(path, state, action.value);
+                        if (!action.inBatch) {
+                            return produce(state, (draft) => {
+                                validateNode(path, draft);
+                                performConditionChecks(draft, state, blockClientId);
+                            });
+                        }
+                        return state;
+                }
+                return state; // WordPress likes hammering redux stores with invalid actions for some reason, so we have to have this
+            }
+        });
+        function getDataStoreImpl(property, required) {
+            return required ? getDataStore(property, store.getState(), true) : getDataStore(property, store.getState(), false);
+        }
+        const dataController = {
+            dispatch(action) {
+                return store.dispatch(action);
+            },
+            getDataStore: getDataStoreImpl,
+            getAllDataStores() {
+                return store.getState().dataStores.list;
+            },
+            makePropertyValueResolver(contextPath) {
+                return propertyPath => resolveValueForCondition(propertyPath, contextPath, blockClientId, getDataStoreImpl);
+            },
+            getValue(path) {
+                return getOptionalValue(path, store.getState());
+            },
+            setValue(path, value) {
+                store.dispatch({ type: "writeValue", path, value });
+            },
+            addProperties(properties, dataStore, inBatch) {
+                store.dispatch({ type: "addProperties", properties, dataStore, inBatch });
+            },
+            addNode(path, value) {
+                try {
+                    store.dispatch({ type: "addNode", 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), inBatch: true });
+                        }
+                        store.dispatch({ type: "addNode", path, value });
+                    }
+                    throw e;
+                }
+            },
+            removeNode(path) {
+                store.dispatch({ type: "removeNode", path });
+            },
+            moveNode(path, indices) {
+                store.dispatch({ type: "moveNode", path, ...indices });
+            },
+            hasRenderedNode(properties) {
+                const rootNodes = store.getState().treeRoot.children;
+                for (const property of properties) {
+                    if (Array.isArray(property)) {
+                        for (const prop of property) {
+                            if (rootNodes[prop.name]?.rendered) {
+                                return true;
+                            }
+                        }
+                    }
+                    else if (rootNodes[property.name]?.rendered) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            hasValidationErrors(properties) {
+                if (properties === undefined) {
+                    return testForValidationErrors(store.getState().treeRoot);
+                }
+                const rootNodes = store.getState().treeRoot.children;
+                for (const property of properties) {
+                    if (Array.isArray(property)) {
+                        for (const prop of property) {
+                            if (testForValidationErrors(rootNodes[prop.name])) {
+                                return true;
+                            }
+                        }
+                    }
+                    else if (testForValidationErrors(rootNodes[property.name])) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            getIsRendered(path) {
+                return walkToNode(store.getState().treeRoot, path).rendered ?? true;
+            },
+            getNode(path) {
+                return walkToNode(store.getState().treeRoot, path);
+            },
+            getValidationError(path) {
+                return walkToNode(store.getState().treeRoot, path).validationError;
+            }
+        };
+        return dataController;
+    }, [blockClientId]);
+}
+function getOptionalValue(path, state) {
+    try {
+        return walkToNodeInValue(getDataStore(path[0], state).getValue(path[0]), path);
+    }
+    catch (e) {
+        if (e instanceof PathError) {
+            return undefined;
+        }
+        throw e;
+    }
+}
+function testForValidationErrors(node) {
+    if (!node || !node.rendered) {
+        return false;
+    }
+    else if (node.validationError) {
+        return true;
+    }
+    else if (Array.isArray(node.children)) {
+        for (const child of node.children) {
+            if (testForValidationErrors(child)) {
+                return true;
+            }
+        }
+    }
+    else if (node.children !== undefined) {
+        for (const child of Object.values(node.children)) {
+            if (testForValidationErrors(child)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function validateNode(path, draft) {
+    validateFoundNode(walkToNode(draft.treeRoot, path), path, draft);
+}
+function removeFromParentNode(parentNode, path) {
+    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, path, move) {
+    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) {
+    return typeof move.from === 'number' && typeof move.to === 'number';
+}
+function resolveParentNodeDefinition(root, path) {
+    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 buildDefaultValueFromDefinition(definition, forArrayEntry = false) {
+    if (definition === undefined) {
+        return undefined;
+    }
+    else if (definition.default !== undefined || !definition.children?.length) {
+        return definition.default;
+    }
+    else if (forArrayEntry) {
+        if (definition.type !== 'array' && definition.type !== 'object') {
+            return undefined;
+        }
+    }
+    else if (definition.type === 'array') {
+        return [];
+    }
+    else if (definition.type !== 'object') {
+        return undefined;
+    }
+    return Object.fromEntries(definition.children.map(def => [def.name, buildDefaultValueFromDefinition(def)]));
+}
+function populateValueBasedOnDefinition(value, definition, forArrayEntry = false) {
+    if (!definition?.children?.length) {
+        return value;
+    }
+    else if (value === null || value === undefined) {
+        return buildDefaultValueFromDefinition(definition, forArrayEntry);
+    }
+    else if (typeof value !== 'object') {
+        return value;
+    }
+    else if (Array.isArray(value)) {
+        return value;
+    }
+    return { ...value, ...Object.fromEntries(definition.children.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("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;
+}
+function performConditionChecks(draft, state, blockClientId) {
+    const 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;
+                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;
+        }
+    });
+}
+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) {
+            const dataStore = getDataStore(path[0], draft);
+            dataStore.blockEditProps.setAttributes({ __plauditGAEValidationTicker: (dataStore.blockEditProps.attributes['__plauditGAEValidationTicker'] ?? 0) + 1 });
+            node.validationError = validationError;
+        }
+    }
+}
+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));
+    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.`);
+    if (!dataStore) {
+        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], 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("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("Encountered a path pointing to a non-existent root node.", path, 0);
+    }
+    const dataStore = getDataStore(path[0], state);
+    if (path.length === 1) {
+        dataStore.setValue(path[0], value ?? buildDefaultValueFromDefinition(rootDCNode.definition));
+        return;
+    }
+    dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsValueDraft) => {
+        let currentDSValue = dsValueDraft;
+        let closestUsableDefinition = rootDCNode.definition;
+        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) {
+                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);
+        }
+        currentDSValue[nodeName] = value;
+    }));
+}
+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], 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("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, path) {
+    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, path, i) {
+    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;
+}
+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') {
+                return {
+                    rendered: true, condition: definition.condition, definition, validationError: "",
+                    children: Object.fromEntries(children.map(def => [def.name, buildNodeFromDataAndDefinition(undefined, def)]))
+                };
+            }
+        }
+        else if (typeof data === 'object') {
+            if (Array.isArray(data)) {
+                return {
+                    rendered: true, condition: definition.condition, definition, validationError: "", children: data.map(item => {
+                        return {
+                            children: Object.fromEntries(children.map(def => [def.name, buildNodeFromDataAndDefinition(item[def.name], def)])),
+                            rendered: true, validationError: ""
+                        };
+                    })
+                };
+            }
+            else {
+                return {
+                    rendered: true, condition: definition.condition, definition, validationError: "",
+                    children: Object.fromEntries(children.map(def => [def.name, buildNodeFromDataAndDefinition(data[def.name], def)]))
+                };
+            }
+        }
+    }
+    return { rendered: true, condition: definition.condition, definition, validationError: "" };
+}
+//# sourceMappingURL=data-controller.js.map