json-to-spec 19.1.0

package/src/v14/iterate/bindFormValues.js

@@ -0,0 +1,74 @@
+/**
+ * Recursively binds form field values into
+ * input, textarea, select and option nodes.
+ */
+const bindFormValues = ({ inNode, inItem, inData }) => {
+    const localNode = inNode;
+    const localItem = inItem;
+    const localData = inData;
+
+    if (!localNode || typeof localNode !== "object") {
+        return localNode;
+    }
+
+    if (localNode.attributes) {
+        const isFormField = [
+            "input",
+            "textarea",
+            "select",
+            "option"
+        ].includes(localNode.tagName?.toLowerCase());
+
+        if (isFormField) {
+            const fieldName =
+                localItem.field ||
+                localItem.columnName ||
+                localItem.name;
+
+            if (
+                localItem.value !== undefined &&
+                localItem.value !== null
+            ) {
+                localNode.attributes.value = String(localItem.value);
+
+                if (
+                    localNode.tagName === "textarea" &&
+                    !localNode.textContent
+                ) {
+                    localNode.textContent = String(localItem.value);
+                }
+            } else if (
+                fieldName &&
+                localData[fieldName] !== undefined &&
+                localData[fieldName] !== null
+            ) {
+                localNode.attributes.value = String(
+                    localData[fieldName]
+                );
+
+                if (
+                    localNode.tagName === "textarea" &&
+                    !localNode.textContent
+                ) {
+                    localNode.textContent = String(
+                        localData[fieldName]
+                    );
+                }
+            }
+        }
+    }
+
+    if (Array.isArray(localNode.children)) {
+        localNode.children.forEach(child => {
+            bindFormValues({
+                inNode: child,
+                inItem: localItem,
+                inData: localData
+            });
+        });
+    }
+
+    return localNode;
+};
+
+export default bindFormValues;

package/src/v14/iterate/expandIteration.js

@@ -0,0 +1,188 @@
+import resolveCollection from "./resolveCollection.js";
+import bindFormValues from "./bindFormValues.js";
+import { replaceNode } from "../replace.js";
+
+/**
+ * Expands a single iteration directive into an array of
+ * specification nodes.
+ */
+const expandIteration = ({
+    inNode,
+    inContext,
+    inData,
+    walk
+}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    const instruction = localNode && (
+        localNode.jsonToSpec ||
+        (localNode.operation ? localNode : null)
+    );
+
+    if (!instruction) return undefined;
+
+    const operationType = instruction.operation;
+
+    if (
+        operationType !== "iterate" &&
+        !instruction.source &&
+        !instruction.$iterate
+    ) {
+        return undefined;
+    }
+
+    const sourceKey =
+        instruction.source ||
+        instruction.iterateOn ||
+        instruction.$iterate;
+
+    const collection = resolveCollection({
+        inNode: localNode,
+        inContext: localContext,
+        inData: localData
+    }) || [];
+
+    if (!Array.isArray(collection)) {
+        if (localNode && localNode.tagName) {
+            const cloned = { ...localNode };
+            delete cloned.jsonToSpec;
+            cloned.children = [];
+            return cloned;
+        }
+
+        return [];
+    }
+
+    const template =
+        instruction.template ||
+        instruction.item ||
+        {};
+
+    const filter = instruction.filter;
+
+    const filtered = collection.filter(item => {
+        if (!item || typeof item !== "object") {
+            return true;
+        }
+
+        if (filter && typeof filter === "object") {
+            for (const [key, value] of Object.entries(filter)) {
+                if (item[key] !== value) {
+                    return false;
+                }
+            }
+        }
+
+        if (item.isVisible === false) {
+            return false;
+        }
+
+        return true;
+    });
+
+    const expandedChildren = [];
+
+    filtered.forEach((item, index) => {
+        const itemContext = {
+            ...localContext,
+            item,
+            ...(typeof item === "object" && item !== null ? item : {}),
+            $index: index,
+            $number: index + 1
+        };
+
+        if (
+            sourceKey === "rows" ||
+            sourceKey.endsWith(".rows") ||
+            sourceKey === "items" ||
+            sourceKey.endsWith("Rows")
+        ) {
+            itemContext.row = item;
+        }
+
+        if (
+            localContext.row &&
+            (item.field || item.columnName || item.name)
+        ) {
+            const fieldKey =
+                item.field ||
+                item.columnName ||
+                item.name;
+
+            const cellValue = localContext.row[fieldKey];
+
+            if (cellValue !== undefined) {
+                itemContext.cellValue = cellValue;
+                itemContext.value = cellValue;
+
+                if (
+                    typeof item === "object" &&
+                    item !== null &&
+                    item.value === undefined
+                ) {
+                    item.value = cellValue;
+                }
+            }
+        }
+
+        const rawTemplate =
+            typeof template === "object" &&
+                template !== null
+                ? JSON.parse(JSON.stringify(template))
+                : {
+                    tagName: "span",
+                    textContent: template
+                };
+
+        const iteratedTemplate = walk({
+            inNode: rawTemplate,
+            inContext: itemContext,
+            inData: localData,
+            inOperation: ({ inNode, inContext, inData }) => {
+                return expandIteration({
+                    inNode,
+                    inContext,
+                    inData,
+                    walk
+                });
+            }
+        });
+
+        const replacedTemplate = replaceNode({
+            inNode: iteratedTemplate,
+            inContext: itemContext,
+            inData: localData
+        });
+
+        bindFormValues({
+            inNode: replacedTemplate,
+            inItem: item,
+            inData: localData
+        });
+
+        if (Array.isArray(replacedTemplate)) {
+            expandedChildren.push(...replacedTemplate);
+        } else if (
+            replacedTemplate !== null &&
+            replacedTemplate !== undefined
+        ) {
+            expandedChildren.push(replacedTemplate);
+        }
+    });
+
+    if (localNode && localNode.tagName) {
+        const cloned = { ...localNode };
+
+        delete cloned.jsonToSpec;
+
+        cloned.children = expandedChildren;
+
+        return cloned;
+    }
+
+    return expandedChildren;
+};
+
+export default expandIteration;

package/src/v14/iterate/index.js

@@ -0,0 +1,9 @@
+import iterate from "./iterate.js";
+
+export {
+    iterate
+};
+
+export const operation = iterate;
+
+export default iterate;

package/src/v14/iterate/iterate.js

@@ -0,0 +1,32 @@
+import walk from "./walk/walk.js";
+import expandIteration from "./expandIteration.js";
+
+/**
+ * Iterates a structure by walking the tree
+ * and applying the iteration operation to each node.
+ */
+const iterate = ({
+    inStructure,
+    inData = {},
+    inContext = {}
+} = {}) => {
+    return walk({
+        inNode: inStructure,
+        inData,
+        inContext,
+        inOperation: ({ inNode, inContext, inData }) => {
+            return expandIteration({
+                inNode,
+                inContext,
+                inData,
+                walk
+            });
+        }
+    });
+};
+
+export {
+    iterate
+};
+
+export default iterate;

package/src/v14/iterate/resolveCollection.js

@@ -0,0 +1,37 @@
+import resolvePath from "../resolvePath.js";
+
+/**
+ * Resolves the collection array targeted by an iteration instruction.
+ */
+const resolveCollection = ({ inNode, inContext, inData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    const instruction = localNode && (
+        localNode.jsonToSpec ||
+        (localNode.operation ? localNode : null)
+    );
+
+    if (!instruction) return undefined;
+
+    const sourceKey =
+        instruction.source ||
+        instruction.iterateOn ||
+        instruction.$iterate;
+
+    if (!sourceKey) return undefined;
+
+    return resolvePath({
+        inData: localData,
+        inPath: sourceKey
+    })
+        || (localData && localData[sourceKey])
+        || resolvePath({
+            inData: localContext,
+            inPath: sourceKey
+        })
+        || (localContext && localContext[sourceKey]);
+};
+
+export default resolveCollection;

package/src/v14/iterate/walk/walk copy 2.js

@@ -0,0 +1,114 @@
+
+/**
+ * Applies the supplied operation to the current node.
+ */
+const applyOperation = ({
+    inNode,
+    inContext = {},
+    inData = {},
+    inOperation
+} = {}) => {
+    if (typeof inOperation !== "function") {
+        return inNode;
+    }
+
+    const operatedNode = inOperation({
+        inNode,
+        inContext,
+        inData
+    });
+
+    return operatedNode === undefined
+        ? inNode
+        : operatedNode;
+};
+
+/**
+ * Recursively walks a JSON structure.
+ *
+ * The walker knows only how to traverse.
+ * The supplied operation decides what to do with each node.
+ */
+const walk = ({
+    inNode,
+    inContext = {},
+    inData = {},
+    inOperation
+} = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    if (localNode === null || localNode === undefined) {
+        return localNode;
+    }
+
+    if (Array.isArray(localNode)) {
+        const results = [];
+
+        for (const child of localNode) {
+            const result = walk({
+                inNode: child,
+                inContext: localContext,
+                inData: localData,
+                inOperation
+            });
+
+            if (Array.isArray(result)) {
+                results.push(...result);
+            } else if (result !== null && result !== undefined) {
+                results.push(result);
+            }
+        }
+
+        return results;
+    }
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    }
+
+    const localOperatedNode = applyOperation({
+        inNode: localNode,
+        inContext: localContext,
+        inData: localData,
+        inOperation
+    });
+
+    if (localOperatedNode === null) {
+        return null;
+    }
+
+    if (Array.isArray(localOperatedNode)) {
+        return walk({
+            inNode: localOperatedNode,
+            inContext: localContext,
+            inData: localData,
+            inOperation
+        });
+    }
+
+    if (typeof localOperatedNode !== "object") {
+        return localOperatedNode;
+    }
+
+    const clone = { ...localOperatedNode };
+
+    if (Array.isArray(clone.children)) {
+        clone.children = walk({
+            inNode: clone.children,
+            inContext: localContext,
+            inData: localData,
+            inOperation
+        });
+    }
+
+    return clone;
+};
+
+export {
+    walk,
+    applyOperation
+};
+
+export default walk;

package/src/v14/iterate/walk/walk copy.js

@@ -0,0 +1,90 @@
+/**
+ * Recursively walks a JSON structure.
+ *
+ * The walker knows only how to traverse.
+ * The supplied operation decides what to do with each node.
+ */
+const walk = ({
+    inNode,
+    inContext = {},
+    inData = {},
+    inOperation
+} = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    if (localNode === null || localNode === undefined) {
+        return localNode;
+    }
+
+    if (Array.isArray(localNode)) {
+        const results = [];
+
+        for (const child of localNode) {
+            const result = walk({
+                inNode: child,
+                inContext: localContext,
+                inData: localData,
+                inOperation
+            });
+
+            if (Array.isArray(result)) {
+                results.push(...result);
+            } else if (result !== null && result !== undefined) {
+                results.push(result);
+            }
+        }
+
+        return results;
+    }
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    }
+
+    const operatedNode = typeof inOperation === "function"
+        ? inOperation({
+            inNode: localNode,
+            inContext: localContext,
+            inData: localData
+        })
+        : localNode;
+
+    const localOperatedNode =
+        operatedNode === undefined
+            ? localNode
+            : operatedNode;
+
+    if (localOperatedNode === null) {
+        return null;
+    }
+
+    if (Array.isArray(localOperatedNode)) {
+        return walk({
+            inNode: localOperatedNode,
+            inContext: localContext,
+            inData: localData,
+            inOperation
+        });
+    }
+
+    if (typeof localOperatedNode !== "object") {
+        return localOperatedNode;
+    }
+
+    const clone = { ...localOperatedNode };
+
+    if (Array.isArray(clone.children)) {
+        clone.children = walk({
+            inNode: clone.children,
+            inContext: localContext,
+            inData: localData,
+            inOperation
+        });
+    }
+
+    return clone;
+};
+
+export default walk;

package/src/v14/iterate/walk/walk.js

@@ -0,0 +1,98 @@
+const replaceWithData = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if ("textContent" in inNode) {
+        if (inNode.textContent.includes("${")) {
+            const dataKey = inNode.textContent
+                .replace(/^\$\{/, "")
+                .replace(/\}$/, "");
+
+            if (dataKey.includes(".")) {
+                const keysOfArray = dataKey.split(".");
+
+                const value = keysOfArray.reduce(
+                    (current, key) => current?.[key],
+                    inData
+                );
+
+                inNode.textContent = value;
+            };
+        };
+    };
+};
+
+const forArray = ({ inNode, inData }) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (Array.isArray(localNode)) {
+        const results = [];
+
+        for (const child of localNode) {
+            const result = walk({
+                inNode: child,
+                inData
+            });
+
+            if (Array.isArray(result)) {
+                results.push(...result);
+            } else if (result !== null && result !== undefined) {
+                results.push(result);
+            };
+        };
+
+        return results;
+    };
+};
+
+/**
+ * Recursively walks a JSON structure.
+ *
+ * The walker knows only how to traverse.
+ * The supplied operation decides what to do with each node.
+ */
+const walk = ({
+    inNode,
+    inData = {},
+    inOperation
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (localNode === null || localNode === undefined) {
+        return localNode;
+    }
+
+    if (Array.isArray(localNode)) {
+        return forArray({ inNode: localNode, inData });
+    };
+
+    if ("children" in localNode) {
+        if (Array.isArray(localNode?.children)) {
+            localNode.children = forArray({
+                inNode: localNode?.children,
+                inData
+            });
+        };
+    };
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    };
+
+    if (typeof localNode === "object") {
+        replaceWithData({ inNode, inData });
+    };
+
+    return localNode;
+};
+
+export {
+    walk
+};
+
+export default walk;