json-to-spec 19.1.0

package/src/v17/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/v17/iterate/walk/iterateDo.js

@@ -0,0 +1,42 @@
+import walk from "./walk.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if ("jsonToSpec" in localNode) {
+
+        if ("operation" in localNode?.jsonToSpec) {
+            if (localNode?.jsonToSpec?.operation === "iterate") {
+
+                if ("source" in localNode?.jsonToSpec) {
+                    const sourceValues = inData[localNode?.jsonToSpec?.source];
+
+                    const newChildren = sourceValues.map(loopColumn => {
+                        const clone = structuredClone(localNode?.jsonToSpec?.template);
+
+                        const k1 = walk({
+                            inNode: clone,
+                            inData: loopColumn,
+                            inOperation: "replace"
+                        });
+
+                        return k1
+                    });
+
+                    localNode.children = newChildren;
+
+                };
+
+            };
+        };
+    };
+
+    // console.log("localNode : ", localNode);
+
+};
+
+export default startFunc;

package/src/v17/iterate/walk/replaceWithData.js

@@ -0,0 +1,60 @@
+const replaceCommonFunc = ({ inData, inDataKey }) => {
+    const dataKey = inDataKey;
+    // console.log("dataKey : ", dataKey, inData);
+
+    let valueToReturn = inData[dataKey];
+
+    if (dataKey.includes(".")) {
+        const keysOfArray = dataKey.split(".");
+
+        const value = keysOfArray.reduce(
+            (current, key) => current?.[key],
+            inData
+        );
+
+        valueToReturn = value;
+    };
+
+    return valueToReturn;
+};
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if ("textContent" in inNode) {
+        if (inNode.textContent.includes("${")) {
+            const dataKey = inNode.textContent
+                .replace(/^\$\{/, "")
+                .replace(/\}$/, "");
+
+            inNode.textContent = replaceCommonFunc({ inData, inDataKey: dataKey });
+
+        };
+    };
+
+    if ("attributes" in inNode) {
+        const attributes = Object.fromEntries(
+            Object.entries(inNode.attributes || {}).map(([key, value]) => [
+                key,
+                typeof value === "string" && value.includes("${")
+                    ? replaceCommonFunc({
+                        inData,
+                        inDataKey: value
+                            .replace(/^\$\{/, "")
+                            .replace(/\}$/, "")
+                    })
+                    : value
+            ])
+        );
+
+        // console.log("attributes----- : ", inNode, attributes);
+
+        inNode.attributes = { ...attributes };
+    };
+};
+
+export default startFunc;

package/src/v17/iterate/walk/walk.js

@@ -0,0 +1,94 @@
+import replaceWithData from "./replaceWithData.js";
+import iterateDo from "./iterateDo.js";
+
+const forArray = ({ inNode, inData, inOperation }) => {
+    const localNode = inNode;
+    const localData = inData;
+    const localOperation = inOperation;
+
+    // console.log("forArray : ", inNode, inOperation);
+
+    if (Array.isArray(localNode)) {
+        const results = [];
+
+        for (const child of localNode) {
+            const result = walk({
+                inNode: child,
+                inData, inOperation: localOperation
+            });
+
+            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;
+    const localOperation = inOperation;
+    // debugger
+    if (localNode === null || localNode === undefined) {
+        return localNode;
+    }
+
+    if (Array.isArray(localNode)) {
+        return forArray({
+            inNode: localNode, inData,
+            inOperation: localOperation
+        });
+    };
+
+    if ("children" in localNode) {
+        if (Array.isArray(localNode?.children)) {
+            localNode.children = forArray({
+                inNode: localNode?.children,
+                inData, inOperation: localOperation
+            });
+        };
+    };
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    };
+
+    // console.log("localOperation :", localOperation);
+
+    switch (localOperation) {
+        case "replace":
+            if (typeof localNode === "object") {
+                // console.log("yyyyyyyyyy :", typeof localNode === "object");
+                replaceWithData({
+                    inNode: localNode,
+                    inData
+                });
+            };
+            break;
+        case "iterateDo":
+            iterateDo({
+                inNode: localNode,
+                inData
+            });
+        default:
+            break;
+    };
+
+    return localNode;
+};
+
+export default walk;

package/src/v17/iterate.js

@@ -0,0 +1,270 @@
+import resolvePath from "./resolvePath.js";
+import { replaceNode } from "./replace.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]);
+};
+
+/**
+ * Recursively binds form field values into input, textarea, select, 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;
+};
+
+/**
+ * Expands a single iteration directive into an array of DOM element nodes.
+ */
+const expandIteration = ({ 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 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;
+                }
+            }
+        }
+
+        // 1. Clone the template
+        const rawTemplate = typeof template === "object" && template !== null
+            ? JSON.parse(JSON.stringify(template))
+            : { tagName: "span", textContent: template };
+
+        // 2. Expand any nested iterations within the template
+        const iteratedTemplate = iterateNode({
+            inNode: rawTemplate,
+            inContext: itemContext,
+            inData: localData
+        });
+
+        // 3. Replace item-level tokens in the template
+        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 jsonToSpec was a sibling on a container node (e.g. <div class="row" jsonToSpec="...">)
+    if (localNode && localNode.tagName) {
+        const cloned = { ...localNode };
+        delete cloned.jsonToSpec;
+        cloned.children = expandedChildren;
+        return cloned;
+    }
+
+    return expandedChildren;
+};
+
+/**
+ * Recursively walks a JSON tree and resolves all jsonToSpec iteration directives.
+ */
+export const iterateNode = ({ inNode, inContext = {}, inData = {} } = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    if (localNode === null || localNode === undefined) return localNode;
+
+    if (Array.isArray(localNode)) {
+        const flattened = [];
+        for (const child of localNode) {
+            const processed = iterateNode({
+                inNode: child,
+                inContext: localContext,
+                inData: localData
+            });
+
+            if (Array.isArray(processed)) {
+                flattened.push(...processed);
+            } else if (processed !== null && processed !== undefined) {
+                flattened.push(processed);
+            }
+        }
+        return flattened;
+    }
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    }
+
+    // Check if current node is or has an iteration directive
+    const iterationResult = expandIteration({
+        inNode: localNode,
+        inContext: localContext,
+        inData: localData
+    });
+
+    if (iterationResult !== undefined) {
+        return iterationResult;
+    }
+
+    // Standard node: recursively process children
+    const clone = { ...localNode };
+
+    if (Array.isArray(clone.children)) {
+        const processedChildren = [];
+        for (const child of clone.children) {
+            const processed = iterateNode({
+                inNode: child,
+                inContext: localContext,
+                inData: localData
+            });
+
+            if (Array.isArray(processed)) {
+                processedChildren.push(...processed);
+            } else if (processed !== null && processed !== undefined) {
+                processedChildren.push(processed);
+            }
+        }
+        clone.children = processedChildren;
+    }
+
+    return clone;
+};
+
+/**
+ * Main iterate/operation function: (structure, data) -> expanded JSON specification
+ */
+export const iterate = (inStructureOrOptions, inData = {}) => {
+    let localStructure = inStructureOrOptions;
+    let localData = inData;
+    let localContext = {};
+
+    if (inStructureOrOptions && typeof inStructureOrOptions === "object" && !Array.isArray(inStructureOrOptions)) {
+        if ("inStructure" in inStructureOrOptions || "inTree" in inStructureOrOptions || "inNode" in inStructureOrOptions) {
+            localStructure = inStructureOrOptions.inStructure || inStructureOrOptions.inTree || inStructureOrOptions.inNode;
+            localData = inStructureOrOptions.inData || localData;
+            localContext = inStructureOrOptions.inContext || localContext;
+        } else if ("structure" in inStructureOrOptions) {
+            localStructure = inStructureOrOptions.structure;
+            localData = inStructureOrOptions.data || localData;
+            localContext = inStructureOrOptions.context || localContext;
+        }
+    }
+
+    return iterateNode({
+        inNode: localStructure,
+        inContext: localContext,
+        inData: localData
+    });
+};
+
+export const operation = iterate;
+export default iterate;

package/src/v17/replace/index.js

@@ -0,0 +1,16 @@
+/**
+ * replace/index.js
+ *
+ * Responsibility:
+ * - Provide the public replace API for the v14 replace phase.
+ * - For now this is a thin wrapper that re-exports the existing
+ *   implementation in `../replace.js` so no public imports break.
+ * - Later the implementation can be moved into this folder and
+ *   the wrapper updated accordingly.
+ */
+
+import replaceDefault, { replace, replaceNode } from "../replace.js";
+
+export { replace, replaceNode };
+
+export default replaceDefault;

package/src/v17/replace/walk.js

@@ -0,0 +1,90 @@
+/**
+ * Recursively walks a JSON structure for the replace phase.
+ *
+ * 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;