json-to-spec 19.1.0

package/src/v17/replace.js

@@ -0,0 +1,160 @@
+import resolvePath from "./resolvePath.js";
+import walk from "./iterate/walk/walk.js";
+
+/**
+ * Resolves a token expression path against local context first, then root data.
+ */
+const resolveTokenValue = ({ inPath, inContext, inData }) => {
+    const localPath = inPath;
+    const localContext = inContext;
+    const localData = inData;
+
+    let value = resolvePath({ inData: localContext, inPath: localPath });
+
+    if (value === undefined && localContext && typeof localContext === "object") {
+        if (localContext.item && typeof localContext.item === "object") {
+            value = resolvePath({ inData: localContext.item, inPath: localPath });
+        }
+        if (value === undefined && localContext.row && typeof localContext.row === "object") {
+            value = resolvePath({ inData: localContext.row, inPath: localPath });
+        }
+    }
+
+    if (value === undefined && localData) {
+        value = resolvePath({ inData: localData, inPath: localPath });
+    }
+
+    return value;
+};
+
+/**
+ * Replaces ${path} tokens in a string value.
+ */
+const replaceValue = ({ inValue, inContext, inData }) => {
+    const localValue = inValue;
+    const localContext = inContext;
+    const localData = inData;
+
+    if (typeof localValue !== "string" || !localValue.includes("${")) {
+        return localValue;
+    }
+
+    const hasItemContext = Boolean(localContext && (localContext.item || Object.keys(localContext).length > 0));
+
+    // Exact match: "${path}" -> preserve primitive types (boolean, number, object)
+    const exactMatch = localValue.match(/^\$\{([^}]+)\}$/);
+    if (exactMatch) {
+        const token = resolveTokenValue({
+            inPath: exactMatch[1].trim(),
+            inContext: localContext,
+            inData: localData
+        });
+        return token !== undefined && token !== null ? token : (hasItemContext ? "" : localValue);
+    }
+
+    // Substring interpolation: "Hello ${name}" -> string replacement
+    return localValue.replace(/\$\{([^}]+)\}/g, (fullMatch, expr) => {
+        const token = resolveTokenValue({
+            inPath: expr.trim(),
+            inContext: localContext,
+            inData: localData
+        });
+        return token !== undefined && token !== null ? String(token) : (hasItemContext ? "" : fullMatch);
+    });
+};
+
+/**
+ * Recursively walks a JSON tree and replaces all ${...} tokens against data.
+ */
+export const replaceNode = ({ inNode, inContext = {}, inData = {} } = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localData = inData;
+
+    if (localNode === null || localNode === undefined) return localNode;
+
+    if (Array.isArray(localNode)) {
+        return localNode.map(child => replaceNode({
+            inNode: child,
+            inContext: localContext,
+            inData: localData
+        }));
+    }
+
+    if (typeof localNode === "string") {
+        return replaceValue({
+            inValue: localNode,
+            inContext: localContext,
+            inData: localData
+        });
+    }
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    }
+
+    const clone = { ...localNode };
+
+    if (clone.textContent && typeof clone.textContent === "string") {
+        clone.textContent = replaceValue({
+            inValue: clone.textContent,
+            inContext: localContext,
+            inData: localData
+        });
+    }
+
+    if (clone.attributes) {
+        clone.attributes = { ...clone.attributes };
+        for (const [name, val] of Object.entries(clone.attributes)) {
+            if (typeof val === "string") {
+                clone.attributes[name] = replaceValue({
+                    inValue: val,
+                    inContext: localContext,
+                    inData: localData
+                });
+            }
+        }
+    }
+
+    if (clone.properties) {
+        clone.properties = { ...clone.properties };
+        for (const [name, val] of Object.entries(clone.properties)) {
+            if (typeof val === "string") {
+                clone.properties[name] = replaceValue({
+                    inValue: val,
+                    inContext: localContext,
+                    inData: localData
+                });
+            }
+        }
+    }
+
+    if (Array.isArray(clone.children)) {
+        clone.children = clone.children.map(child => replaceNode({
+            inNode: child,
+            inContext: localContext,
+            inData: localData
+        }));
+    }
+
+    return clone;
+};
+
+/**
+ * Main replace function: (structure, data) -> replaced JSON structure
+ */
+export const replace = ({ inStructureAsJson, inDataAsJson, inOperation }) => {
+    // console.log("inDataAsJson-------- : ", inDataAsJson);
+
+    try {
+        return walk({
+            inNode: inStructureAsJson,
+            inData: inDataAsJson, inOperation
+        });
+    } catch (err) {
+        console.error("[json-to-spec/v17] replace error:", err);
+        throw err;
+    }
+};
+
+export default replace;

package/src/v17/resolvePath.js

@@ -0,0 +1,29 @@
+/**
+ * Resolves a dot-delimited path or array of keys from a data object.
+ *
+ * @param {Object} inArgs
+ * @param {Object} inArgs.inData - Target object to resolve from
+ * @param {string|Array} inArgs.inPath - Key or dot-path (e.g. "meta.formTitle", "columns")
+ * @returns {*} Resolved value or undefined
+ */
+export const resolvePath = ({ inData, inPath }) => {
+    const localData = inData;
+    const localPath = inPath;
+
+    if (localData === null || localData === undefined) return undefined;
+    if (localPath === undefined || localPath === null || localPath === "" || localPath === ".") {
+        return localData;
+    }
+
+    const segments = Array.isArray(localPath) ? localPath : String(localPath).split(".");
+    let current = localData;
+
+    for (const segment of segments) {
+        if (current === null || current === undefined) return undefined;
+        current = current[segment];
+    }
+
+    return current;
+};
+
+export default resolvePath;

package/src/v18/index.js

@@ -0,0 +1,66 @@
+import registerGlobal from "./registerGlobal.js";
+/**
+ * json-to-spec v11
+ *
+ * Minimalist 2-Layer Specification Compiler:
+ * 1. replace: Pure ${...} token replacement across JSON structures.
+ * 2. iterate: Evaluates jsonToSpec operations, expanding collections into clean children.
+ */
+
+import { replace } from "./replace.js";
+
+export const meta = {
+    version: "18.0.0",
+    name: "json-to-spec/v18",
+    description: "Minimalist 2-layer compiler: pure value replace + jsonToSpec iterate"
+};
+
+/**
+ * Main compiler entry point:
+ * 1. Replace values: replace(structure, data)
+ * 2. Iterate/Operate: iterate(replacedStructure, data)
+ */
+export const compile = (inStructureOrOptions, inData = {}, inShowLog = false) => {
+    let localStructure = inStructureOrOptions;
+    let localData = inData;
+
+    if (inShowLog) console.log(meta.name, localStructure, localData);
+
+    try {
+        const iteratedData = replace({
+            inStructureAsJson: localStructure,
+            inDataAsJson: localData,
+            inOperation: "iterateDo"
+        });
+
+        const replacedData = replace({
+            inStructureAsJson: iteratedData,
+            inDataAsJson: localData,
+            inOperation: "replace"
+        });
+
+        console.log("iteratedData : ", iteratedData, replacedData);
+
+        // const spec = iterate({
+        //     inStructure: replaced,
+        //     inData: localData
+        // });
+
+        return replacedData;
+    } catch (err) {
+        console.error("[json-to-spec/v17] compile error:", err);
+        throw err;
+    }
+};
+
+// if (typeof globalThis !== "undefined") {
+//     globalThis.ks ??= {};
+//     globalThis.ks["json-to-spec"] = {
+//         meta,
+//         compile
+//     };
+// };
+
+registerGlobal(compile);
+
+export default compile;

package/src/v18/meta.js

@@ -0,0 +1,7 @@
+export const meta = {
+    version: "18.0.0",
+    name: "json-to-spec/v18",
+    description: "Minimalist 2-layer compiler: pure value replace + jsonToSpec iterate"
+};
+
+export default meta;

package/src/v18/registerGlobal.js

@@ -0,0 +1,17 @@
+import meta from "./meta.js";
+
+/**
+ * 3. registerGlobal - Orchestration Step 3
+ * Safely registers the json-to-dom public API onto globalThis.ks in browser / SSR environments.
+ */
+export const registerGlobal = (inFuncDefinition) => {
+    if (typeof globalThis === "undefined" || !inFuncDefinition) return;
+
+    globalThis.ks ??= {};
+    globalThis.ks["json-to-spec"] = {
+        meta,
+        compile: inFuncDefinition
+    };
+};
+
+export default registerGlobal;

package/src/v18/replace.js

@@ -0,0 +1,18 @@
+import walk from "./walk/walk.js";
+
+/**
+ * Main replace function: (structure, data) -> replaced JSON structure
+ */
+export const replace = ({ inStructureAsJson, inDataAsJson, inOperation }) => {
+    try {
+        return walk({
+            inNode: inStructureAsJson,
+            inData: inDataAsJson, inOperation
+        });
+    } catch (err) {
+        console.error("[json-to-spec/v17] replace error:", err);
+        throw err;
+    };
+};
+
+export default replace;

package/src/v18/resolvePath.js

@@ -0,0 +1,29 @@
+/**
+ * Resolves a dot-delimited path or array of keys from a data object.
+ *
+ * @param {Object} inArgs
+ * @param {Object} inArgs.inData - Target object to resolve from
+ * @param {string|Array} inArgs.inPath - Key or dot-path (e.g. "meta.formTitle", "columns")
+ * @returns {*} Resolved value or undefined
+ */
+export const resolvePath = ({ inData, inPath }) => {
+    const localData = inData;
+    const localPath = inPath;
+
+    if (localData === null || localData === undefined) return undefined;
+    if (localPath === undefined || localPath === null || localPath === "" || localPath === ".") {
+        return localData;
+    }
+
+    const segments = Array.isArray(localPath) ? localPath : String(localPath).split(".");
+    let current = localData;
+
+    for (const segment of segments) {
+        if (current === null || current === undefined) return undefined;
+        current = current[segment];
+    }
+
+    return current;
+};
+
+export default resolvePath;

package/src/v18/walk/iterate/v1/index.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/v18/walk/iterate/v2/index.js

@@ -0,0 +1,32 @@
+import walk from "../../walk.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (!("jsonToSpec" in localNode)) return;
+    if (!("operation" in localNode.jsonToSpec)) return;
+    if (localNode.jsonToSpec.operation !== "iterate") return;
+    if (!("source" in localNode.jsonToSpec)) return;
+
+    const sourceValues = localData[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;
+};
+
+export default startFunc;

package/src/v18/walk/iterate/v3/index.js

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

package/src/v18/walk/iterate/v4/createChildren.js

@@ -0,0 +1,24 @@
+import walk from "../../walk.js";
+
+const startFunc = ({
+    inTemplate,
+    inSourceValues,
+} = {}) => {
+    const sourceValues = inSourceValues;
+
+    const newChildren = sourceValues.map(loopColumn => {
+        const clone = structuredClone(inTemplate);
+
+        const walkResult = walk({
+            inNode: clone,
+            inData: loopColumn,
+            inOperation: "replace"
+        });
+
+        return walkResult;
+    });
+
+    return newChildren;
+};
+
+export default startFunc;

package/src/v18/walk/iterate/v4/index.js

@@ -0,0 +1,25 @@
+import createChildren from "./createChildren.js";
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (!("jsonToSpec" in localNode)) return;
+    if (!("operation" in localNode.jsonToSpec)) return;
+    if (localNode.jsonToSpec.operation !== "iterate") return;
+    if (!("source" in localNode.jsonToSpec)) return;
+
+    const sourceValues = localData[localNode.jsonToSpec.source];
+
+    const newChildren = createChildren({
+        inTemplate: localNode.jsonToSpec.template,
+        inSourceValues: sourceValues,
+    });
+
+    localNode.children = newChildren;
+};
+
+export default startFunc;

package/src/v18/walk/replaceWithData/v1/index.js

@@ -0,0 +1,42 @@
+import replaceCommonFunc from "./replaceCommon.js";
+
+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/v18/walk/replaceWithData/v1/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/v18/walk/replaceWithData/v2/index.js

@@ -0,0 +1,105 @@
+import replaceCommonFunc from "./replaceCommon.js";
+
+const replaceNodeValue = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    if (localNode?.textContent) {
+        if (localNode.textContent.includes("${")) {
+            const dataKey = localNode.textContent
+                .replace(/^\$\{/, "")
+                .replace(/\}$/, "");
+
+            localNode.textContent = replaceCommonFunc({
+                inData: localData,
+                inDataKey: dataKey
+            });
+        };
+    };
+
+};
+
+const startFunc1 = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    replaceNodeValue({ inNode: localNode, inData: localData });
+
+    // if ("textContent" in localNode) {
+    //     console.log("localNode : ", localNode);
+
+    //     if (localNode.textContent.includes("${")) {
+    //         const dataKey = localNode.textContent
+    //             .replace(/^\$\{/, "")
+    //             .replace(/\}$/, "");
+
+    //         localNode.textContent = replaceCommonFunc({
+    //             inData: localData,
+    //             inDataKey: dataKey
+    //         });
+    //     };
+    // };
+
+    if ("attributes" in localNode) {
+        const attributes = Object.fromEntries(
+            Object.entries(localNode.attributes || {}).map(([key, value]) => [
+                key,
+                typeof value === "string" && value.includes("${")
+                    ? replaceCommonFunc({
+                        inData,
+                        inDataKey: value
+                            .replace(/^\$\{/, "")
+                            .replace(/\}$/, "")
+                    })
+                    : value
+            ])
+        );
+
+        inNode.attributes = { ...attributes };
+    };
+};
+
+const replaceAttributes = ({
+    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 };
+    };
+};
+
+const startFunc = ({
+    inNode,
+    inData,
+} = {}) => {
+    const localNode = inNode;
+    const localData = inData;
+
+    replaceNodeValue({ inNode: localNode, inData: localData });
+    replaceAttributes({ inNode: localNode, inData: localData });
+};
+
+export default startFunc;