json-to-spec 19.1.0

package/src/v19/walk/replaceWithData/v2/replaceCommon.js

@@ -0,0 +1,21 @@
+const startFunc = ({ 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;
+};
+
+export default startFunc;

package/src/v19/walk/replaceWithData/v3/index.js

@@ -0,0 +1,15 @@
+import replaceNodeValue from "./replaceNodeValue.js";
+import replaceAttributes from "./replaceAttributes.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    replaceNodeValue({ inNode: localNode, inData: localData });
+    replaceAttributes({ inNode: localNode, inData: localData });
+};
+
+export default startFunc;

package/src/v19/walk/replaceWithData/v3/replaceAttributes.js

@@ -0,0 +1,29 @@
+import replaceCommonFunc from "./replaceCommon.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if ("attributes" in localNode) {
+        const attributes = Object.fromEntries(
+            Object.entries(localNode.attributes || {}).map(([key, value]) => [
+                key,
+                typeof value === "string" && value.includes("${")
+                    ? replaceCommonFunc({
+                        inData: localData,
+                        inDataKey: value
+                            .replace(/^\$\{/, "")
+                            .replace(/\}$/, "")
+                    })
+                    : value
+            ])
+        );
+
+        localNode.attributes = { ...attributes };
+    };
+};
+
+export default startFunc;

package/src/v19/walk/replaceWithData/v3/replaceCommon.js

@@ -0,0 +1,23 @@
+const startFunc = ({ inData, inDataKey }) => {
+    const dataKey = inDataKey;
+    // console.log("dataKey : ", dataKey, inData);
+
+    if (dataKey === "") return 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;
+};
+
+export default startFunc;

package/src/v19/walk/replaceWithData/v3/replaceNodeValue.js

@@ -0,0 +1,27 @@
+import replaceCommonFunc from "./replaceCommon.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (!localNode?.textContent) return "no-textContent";
+
+    if (typeof localNode.textContent !== "string") return "not-a-string";
+
+    if (!localNode.textContent.includes("${")) return "no-template-token";
+
+    const dataKey = localNode.textContent
+        .replace(/^\$\{/, "")
+        .replace(/\}$/, "");
+
+    localNode.textContent = replaceCommonFunc({
+        inData: localData,
+        inDataKey: dataKey
+    });
+
+};
+
+export default startFunc;

package/src/v19/walk/walk.js

@@ -0,0 +1,97 @@
+import replaceWithData from "./replaceWithData/v3/index.js";
+import iterateDo from "./iterate/v4/index.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,
+    inShowLog = false
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+    const localOperation = inOperation;
+
+    if (inShowLog) console.log("walk ", inNode, inData, 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: localData, inShowLog
+            });
+        default:
+            break;
+    };
+
+    return localNode;
+};
+
+export default walk;

package/src/v8/index.js

@@ -0,0 +1,69 @@
+/**
+ * json-to-spec v7
+ *
+ * Clear separation of responsibilities:
+ * - value replacement is handled by interpolation helpers
+ * - iteration is handled by the dedicated expandIteration layer
+ * - story injection remains a separate final step
+ */
+
+import compileNode from "./instructionEngine/compileTree.js";
+
+export const meta = {
+    version: "8.0.0",
+    name: "json-to-spec/v7",
+    description: "Pure JSON Specification Compiler with separate interpolation and iteration phases"
+};
+
+/**
+ * Compiles a JSON UI structure tree containing `jsonToSpec` operations with a data payload.
+ * 
+ * Outside API:
+ * - compile(structureJson, dataJson)
+ * - compile({ structure, data }) or compile({ context, data })
+ * 
+ * @param {Object|Array} inStructureOrOptions - The UI structure JSON tree or options object
+ * @param {Object} [inData] - Data payload containing collections and values
+ * @returns {Object|Array} - Compiled 100% pure JSON specification ready for json-to-dom
+ */
+const compile = (inStructureOrOptions, inData = {}) => {
+    let localStructure = inStructureOrOptions;
+    let localData = inData || {};
+
+    console.log("aaaaaaaaaa : ", localStructure, localData);
+
+
+    if (inStructureOrOptions && typeof inStructureOrOptions === "object" && !Array.isArray(inStructureOrOptions)) {
+        // Support options object formats
+        if ("structure" in inStructureOrOptions && ("data" in inStructureOrOptions || inData === undefined || Object.keys(inData).length === 0)) {
+            localStructure = inStructureOrOptions.structure;
+            localData = inStructureOrOptions.data || localData;
+        } else if ("context" in inStructureOrOptions && ("data" in inStructureOrOptions || inData === undefined || Object.keys(inData).length === 0)) {
+            localStructure = inStructureOrOptions.context;
+            localData = inStructureOrOptions.data || localData;
+        } else if ("inStructure" in inStructureOrOptions || "inContext" in inStructureOrOptions || "inTree" in inStructureOrOptions) {
+            localStructure = inStructureOrOptions.inStructure || inStructureOrOptions.inContext || inStructureOrOptions.inTree;
+            localData = inStructureOrOptions.inData || localData;
+        }
+    };
+    console.log("aaaaaaaaaa : ", localStructure, localData);
+
+    return compileNode({
+        inNode: localStructure,
+        inContext: localData,
+        inRootData: localData
+    });
+};
+
+if (typeof globalThis !== "undefined") {
+    globalThis.ks ??= {};
+    console.log("aaaaaaaaaa : ", meta);
+
+    globalThis.ks["json-to-spec"] = {
+        meta,
+        compile
+    };
+
+};
+
+export default compile;

package/src/v8/instructionEngine/compile/compileTree.js

@@ -0,0 +1,191 @@
+import { interpolateValue, interpolateString } from "../value/interpolate.js";
+import { injectStory } from "../story/storyInjector.js";
+import { expandIterationNode } from "../iteration/expandIteration.js";
+
+const compileArrayNode = ({ inNode, inContext, inRootData }) => {
+    const flattened = [];
+
+    for (const child of inNode) {
+        const childContext = child && child.__loopItemContext
+            ? { ...inContext, ...child.__loopItemContext }
+            : inContext;
+
+        const compiledChild = compileNode({
+            inNode: child,
+            inContext: childContext,
+            inRootData
+        });
+
+        if (Array.isArray(compiledChild)) {
+            flattened.push(...compiledChild);
+        } else if (compiledChild !== null && compiledChild !== undefined) {
+            flattened.push(compiledChild);
+        }
+    }
+
+    return flattened;
+};
+
+const compilePrimitiveNode = ({ inNode, inContext, inRootData }) => {
+    return interpolateString({
+        inText: inNode,
+        inItemContext: inContext,
+        inRootData
+    });
+};
+
+const applyValueBindings = ({ inNode, inItemContext, inRootData }) => {
+    const clone = { ...inNode };
+
+    if (clone.textContent) {
+        clone.textContent = interpolateString({
+            inText: clone.textContent,
+            inItemContext,
+            inRootData
+        });
+    }
+
+    if (clone.attributes) {
+        clone.attributes = { ...clone.attributes };
+        for (const [name, value] of Object.entries(clone.attributes)) {
+            if (typeof value === "string") {
+                clone.attributes[name] = interpolateValue({
+                    inValue: value,
+                    inItemContext,
+                    inRootData
+                });
+            }
+        }
+    }
+
+    if (clone.properties) {
+        clone.properties = { ...clone.properties };
+        for (const [name, value] of Object.entries(clone.properties)) {
+            if (typeof value === "string") {
+                clone.properties[name] = interpolateValue({
+                    inValue: value,
+                    inItemContext,
+                    inRootData
+                });
+            }
+        }
+    }
+
+    return clone;
+};
+
+const compileStandardNode = ({ inNode, inContext, inRootData }) => {
+    const currentItem = {
+        ...(typeof inContext.item === "object" ? inContext.item : {}),
+        ...inContext
+    };
+
+    const withBindings = applyValueBindings({
+        inNode: { ...inNode },
+        inItemContext: currentItem,
+        inRootData
+    });
+
+    if ("jsonToSpec" in withBindings) {
+        delete withBindings.jsonToSpec;
+    }
+
+    if (withBindings.attributes) {
+        const isFormField = ["input", "textarea", "select", "option"].includes(withBindings.tagName?.toLowerCase());
+        if (isFormField) {
+            const fieldName = currentItem.field || currentItem.columnName || currentItem.name;
+            if (currentItem.value !== undefined && currentItem.value !== null) {
+                withBindings.attributes.value = String(currentItem.value);
+                if (withBindings.tagName === "textarea" && !withBindings.textContent) {
+                    withBindings.textContent = String(currentItem.value);
+                }
+            } else if (fieldName && inRootData[fieldName] !== undefined && inRootData[fieldName] !== null) {
+                withBindings.attributes.value = String(inRootData[fieldName]);
+                if (withBindings.tagName === "textarea" && !withBindings.textContent) {
+                    withBindings.textContent = String(inRootData[fieldName]);
+                }
+            } else if (fieldName && inRootData.values && inRootData.values[fieldName] !== undefined && inRootData.values[fieldName] !== null) {
+                withBindings.attributes.value = String(inRootData.values[fieldName]);
+                if (withBindings.tagName === "textarea" && !withBindings.textContent) {
+                    withBindings.textContent = String(inRootData.values[fieldName]);
+                }
+            }
+        }
+    }
+
+    const storyNode = injectStory(withBindings, inNode, currentItem, inRootData);
+
+    if (Array.isArray(storyNode.children)) {
+        const compiledChildren = [];
+        for (const child of storyNode.children) {
+            const childContext = child && child.__loopItemContext
+                ? { ...inContext, ...child.__loopItemContext }
+                : inContext;
+
+            const compiledChild = compileNode({
+                inNode: child,
+                inContext: childContext,
+                inRootData
+            });
+
+            if (Array.isArray(compiledChild)) {
+                compiledChildren.push(...compiledChild);
+            } else if (compiledChild !== null && compiledChild !== undefined) {
+                compiledChildren.push(compiledChild);
+            }
+        }
+        storyNode.children = compiledChildren;
+    }
+
+    delete storyNode.__loopItemContext;
+    return storyNode;
+};
+
+export const compileNode = ({ inNode, inContext = {}, inRootData = {} } = {}) => {
+    if (inNode === null || inNode === undefined) return null;
+
+    if (Array.isArray(inNode)) {
+        return compileArrayNode({
+            inNode,
+            inContext,
+            inRootData
+        });
+    }
+
+    if (typeof inNode !== "object") {
+        return compilePrimitiveNode({
+            inNode,
+            inContext,
+            inRootData
+        });
+    }
+
+    const iterationResult = expandIterationNode({
+        inNode,
+        inContext,
+        inRootData
+    });
+
+    if (iterationResult !== undefined) {
+        if (Array.isArray(iterationResult)) {
+            return compileArrayNode({
+                inNode: iterationResult,
+                inContext,
+                inRootData
+            });
+        }
+        return compileStandardNode({
+            inNode: iterationResult,
+            inContext,
+            inRootData
+        });
+    }
+
+    return compileStandardNode({
+        inNode,
+        inContext,
+        inRootData
+    });
+};
+
+export default compileNode;

package/src/v8/instructionEngine/compileTree.js

@@ -0,0 +1 @@
+export { compileNode, default } from "./compile/compileTree.js";

package/src/v8/instructionEngine/expandIteration.js

@@ -0,0 +1 @@
+export { expandIterationNode, default } from "./iteration/expandIteration.js";

package/src/v8/instructionEngine/index.js

@@ -0,0 +1,16 @@
+import compileNode from "./compile/compileTree.js";
+import resolvePath from "./resolve/resolvePath.js";
+import { expandIterationNode } from "./iteration/expandIteration.js";
+import { interpolateValue, interpolateString } from "./value/interpolate.js";
+import { injectStory } from "./story/storyInjector.js";
+
+export {
+    compileNode,
+    expandIterationNode,
+    interpolateValue,
+    interpolateString,
+    injectStory,
+    resolvePath
+};
+
+export default compileNode;

package/src/v8/instructionEngine/interpolate.js

@@ -0,0 +1,2 @@
+export { interpolateValue, interpolateString } from "./value/interpolate.js";
+export { default } from "./value/interpolate.js";

package/src/v8/instructionEngine/iteration/expandIteration.js

@@ -0,0 +1,95 @@
+import resolvePath from "../resolve/resolvePath.js";
+
+const resolveCollection = ({ inNode, inContext, inRootData }) => {
+    const instruction = inNode && inNode.jsonToSpec;
+    if (!instruction) return undefined;
+
+    const sourceKey = instruction.source || instruction.iterateOn || instruction.$iterate;
+    if (!sourceKey) return undefined;
+
+    return resolvePath({ inData: inRootData, inPath: sourceKey })
+        || (inRootData && inRootData[sourceKey])
+        || resolvePath({ inData: inContext, inPath: sourceKey })
+        || (inContext && inContext[sourceKey]);
+};
+
+export const expandIterationNode = ({ inNode, inContext = {}, inRootData = {} }) => {
+    const instruction = inNode && inNode.jsonToSpec;
+    if (!instruction) return undefined;
+
+    const operation = instruction.operation;
+    if (operation !== "iterate" && !instruction.source && !instruction.$iterate) {
+        return undefined;
+    }
+
+    const sourceKey = instruction.source || instruction.iterateOn || instruction.$iterate;
+    const collection = resolveCollection({ inNode, inContext, inRootData }) || [];
+
+    if (!Array.isArray(collection)) {
+        if (inNode && inNode.tagName) {
+            const cloned = { ...inNode };
+            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 = {
+            ...inContext,
+            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 (inContext.row && (item.field || item.columnName || item.name)) {
+            const fieldKey = item.field || item.columnName || item.name;
+            const cellValue = inContext.row[fieldKey];
+            if (cellValue !== undefined) {
+                itemContext.cellValue = cellValue;
+                itemContext.value = cellValue;
+                if (typeof item === "object" && item !== null && item.value === undefined) {
+                    item.value = cellValue;
+                }
+            }
+        }
+
+        const templateNode = typeof template === "object" && template !== null
+            ? { ...template, __loopItemContext: itemContext }
+            : { tagName: "span", textContent: template, __loopItemContext: itemContext };
+
+        expandedChildren.push(templateNode);
+    });
+
+    if (inNode && inNode.tagName) {
+        const cloned = { ...inNode };
+        delete cloned.jsonToSpec;
+        cloned.children = expandedChildren;
+        return cloned;
+    }
+
+    return expandedChildren;
+};
+
+export default expandIterationNode;

package/src/v8/instructionEngine/resolve/resolvePath.js

@@ -0,0 +1,18 @@
+export const resolvePath = ({ inData, inPath }) => {
+    if (inData === null || inData === undefined) return undefined;
+    if (inPath === undefined || inPath === null || inPath === "" || inPath === ".") {
+        return inData;
+    }
+
+    const segments = Array.isArray(inPath) ? inPath : String(inPath).split(".");
+    let current = inData;
+
+    for (const segment of segments) {
+        if (current === null || current === undefined) return undefined;
+        current = current[segment];
+    }
+
+    return current;
+};
+
+export default resolvePath;

package/src/v8/instructionEngine/resolve/resolveTokenValue.js

@@ -0,0 +1,22 @@
+import resolvePath from "./resolvePath.js";
+
+export const resolveTokenValue = ({ inPath, inItemContext, inRootData }) => {
+    let value = resolvePath({ inData: inItemContext, inPath });
+
+    if (value === undefined && inItemContext && typeof inItemContext === "object") {
+        if (inItemContext.item && typeof inItemContext.item === "object") {
+            value = resolvePath({ inData: inItemContext.item, inPath });
+        }
+        if (value === undefined && inItemContext.row && typeof inItemContext.row === "object") {
+            value = resolvePath({ inData: inItemContext.row, inPath });
+        }
+    }
+
+    if (value === undefined && inRootData) {
+        value = resolvePath({ inData: inRootData, inPath });
+    }
+
+    return value;
+};
+
+export default resolveTokenValue;

package/src/v8/instructionEngine/resolvePath.js

@@ -0,0 +1 @@
+export { resolvePath, default } from "./resolve/resolvePath.js";

package/src/v8/instructionEngine/resolveTokenValue.js

@@ -0,0 +1 @@
+export { resolveTokenValue, default } from "./resolve/resolveTokenValue.js";