json-to-spec 19.1.0

package/src/v10/instructionEngine/other/other.js

@@ -0,0 +1,150 @@
+import { injectStory } from "../story/storyInjector.js";
+
+const otherArrayNode = ({ inNode, inContext, inRootData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    const flattened = [];
+
+    for (const child of localNode) {
+        const childContext = child && child.__loopItemContext
+            ? { ...localContext, ...child.__loopItemContext }
+            : localContext;
+
+        const processed = otherNode({
+            inNode: child,
+            inContext: childContext,
+            inRootData: localRootData
+        });
+
+        if (Array.isArray(processed)) {
+            flattened.push(...processed);
+        } else if (processed !== null && processed !== undefined) {
+            flattened.push(processed);
+        }
+    }
+
+    return flattened;
+};
+
+const otherStandardNode = ({ inNode, inContext, inRootData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    const currentItem = {
+        ...(typeof localContext.item === "object" ? localContext.item : {}),
+        ...localContext,
+        ...(localNode.__loopItemContext || {})
+    };
+
+    const clone = { ...localNode };
+
+    if (clone.attributes) {
+        clone.attributes = { ...clone.attributes };
+        const isFormField = ["input", "textarea", "select", "option"].includes(clone.tagName?.toLowerCase());
+        if (isFormField) {
+            const fieldName = currentItem.field || currentItem.columnName || currentItem.name;
+            if (currentItem.value !== undefined && currentItem.value !== null) {
+                clone.attributes.value = String(currentItem.value);
+                if (clone.tagName === "textarea" && !clone.textContent) {
+                    clone.textContent = String(currentItem.value);
+                }
+            } else if (fieldName && localRootData[fieldName] !== undefined && localRootData[fieldName] !== null) {
+                clone.attributes.value = String(localRootData[fieldName]);
+                if (clone.tagName === "textarea" && !clone.textContent) {
+                    clone.textContent = String(localRootData[fieldName]);
+                }
+            } else if (fieldName && localRootData.values && localRootData.values[fieldName] !== undefined && localRootData.values[fieldName] !== null) {
+                clone.attributes.value = String(localRootData.values[fieldName]);
+                if (clone.tagName === "textarea" && !clone.textContent) {
+                    clone.textContent = String(localRootData.values[fieldName]);
+                }
+            }
+        }
+    }
+
+    const storyNode = injectStory(clone, localNode, currentItem, localRootData);
+
+    if ("jsonToSpec" in storyNode) {
+        delete storyNode.jsonToSpec;
+    }
+
+    if (Array.isArray(storyNode.children)) {
+        const processedChildren = [];
+        for (const child of storyNode.children) {
+            const childContext = child && child.__loopItemContext
+                ? { ...currentItem, ...child.__loopItemContext }
+                : currentItem;
+
+            const processedChild = otherNode({
+                inNode: child,
+                inContext: childContext,
+                inRootData: localRootData
+            });
+
+            if (Array.isArray(processedChild)) {
+                processedChildren.push(...processedChild);
+            } else if (processedChild !== null && processedChild !== undefined) {
+                processedChildren.push(processedChild);
+            }
+        }
+        storyNode.children = processedChildren;
+    }
+
+    delete storyNode.__loopItemContext;
+    return storyNode;
+};
+
+export const otherNode = ({ inNode, inContext = {}, inRootData = {} } = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    if (localNode === null || localNode === undefined) return null;
+
+    if (Array.isArray(localNode)) {
+        return otherArrayNode({
+            inNode: localNode,
+            inContext: localContext,
+            inRootData: localRootData
+        });
+    }
+
+    if (typeof localNode !== "object") {
+        return localNode;
+    }
+
+    return otherStandardNode({
+        inNode: localNode,
+        inContext: localContext,
+        inRootData: localRootData
+    });
+};
+
+export const other = (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 otherNode({
+        inNode: localStructure,
+        inContext: localContext,
+        inRootData: localData
+    });
+};
+
+export default other;

package/src/v10/instructionEngine/pipeline/pipeline.js

@@ -0,0 +1,47 @@
+import operation from "../operation/operation.js";
+import replace from "../replace/replace.js";
+import other from "../other/other.js";
+
+export const defaultPipeline = [operation, replace, other];
+export const defaultPipeline2 = [replace];
+
+export const pipeline = (inStructureOrOptions, inData = {}, inCustomSteps) => {
+    let localStructure = inStructureOrOptions;
+    let localData = inData;
+    let localSteps = inCustomSteps || defaultPipeline;
+    console.log("inCustomSteps : ", inCustomSteps, localSteps);
+
+    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;
+            localSteps = inStructureOrOptions.inSteps || localSteps;
+        } else if ("structure" in inStructureOrOptions) {
+            localStructure = inStructureOrOptions.structure;
+            localData = inStructureOrOptions.data || localData;
+            localSteps = inStructureOrOptions.steps || localSteps;
+        }
+    }
+
+    let current = localStructure;
+    for (const step of localSteps) {
+        if (typeof step === "function") {
+            current = step({
+                inStructure: current,
+                inData: localData
+            });
+        }
+    }
+
+    return current;
+};
+
+export const pipe = (...inSteps) => {
+    const localSteps = inSteps.length > 0 ? inSteps : defaultPipeline;
+
+    return (inStructureOrOptions, inData = {}) => {
+        return pipeline(inStructureOrOptions, inData, localSteps);
+    };
+};
+
+export default pipeline;

package/src/v10/instructionEngine/replace/replace.js

@@ -0,0 +1,173 @@
+import { interpolateValue, interpolateString } from "../value/interpolate.js";
+
+const replaceArrayNode = ({ inNode, inContext, inRootData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    const flattened = [];
+
+    for (const child of localNode) {
+        const childContext = child && child.__loopItemContext
+            ? { ...localContext, ...child.__loopItemContext }
+            : localContext;
+
+        const replaced = replaceNode({
+            inNode: child,
+            inContext: childContext,
+            inRootData: localRootData
+        });
+
+        if (Array.isArray(replaced)) {
+            flattened.push(...replaced);
+        } else if (replaced !== null && replaced !== undefined) {
+            flattened.push(replaced);
+        }
+    }
+
+    return flattened;
+};
+
+const replacePrimitiveNode = ({ inNode, inContext, inRootData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    if (typeof localNode === "string") {
+        return interpolateString({
+            inText: localNode,
+            inItemContext: localContext,
+            inRootData: localRootData
+        });
+    }
+
+    return localNode;
+};
+
+const replaceStandardNode = ({ inNode, inContext, inRootData }) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    const currentItem = {
+        ...(typeof localContext.item === "object" ? localContext.item : {}),
+        ...localContext,
+        ...(localNode.__loopItemContext || {})
+    };
+
+    const clone = { ...localNode };
+
+    if (clone.textContent && typeof clone.textContent === "string") {
+        clone.textContent = interpolateString({
+            inText: clone.textContent,
+            inItemContext: currentItem,
+            inRootData: localRootData
+        });
+    }
+
+    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: currentItem,
+                    inRootData: localRootData
+                });
+            }
+        }
+    }
+
+    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: currentItem,
+                    inRootData: localRootData
+                });
+            }
+        }
+    }
+
+    if (Array.isArray(clone.children)) {
+        const replacedChildren = [];
+        for (const child of clone.children) {
+            const childContext = child && child.__loopItemContext
+                ? { ...currentItem, ...child.__loopItemContext }
+                : currentItem;
+
+            const replacedChild = replaceNode({
+                inNode: child,
+                inContext: childContext,
+                inRootData: localRootData
+            });
+
+            if (Array.isArray(replacedChild)) {
+                replacedChildren.push(...replacedChild);
+            } else if (replacedChild !== null && replacedChild !== undefined) {
+                replacedChildren.push(replacedChild);
+            }
+        }
+        clone.children = replacedChildren;
+    }
+
+    return clone;
+};
+
+export const replaceNode = ({ inNode, inContext = {}, inRootData = {} } = {}) => {
+    const localNode = inNode;
+    const localContext = inContext;
+    const localRootData = inRootData;
+
+    if (localNode === null || localNode === undefined) return null;
+
+    if (Array.isArray(localNode)) {
+        return replaceArrayNode({
+            inNode: localNode,
+            inContext: localContext,
+            inRootData: localRootData
+        });
+    }
+
+    if (typeof localNode !== "object") {
+        return replacePrimitiveNode({
+            inNode: localNode,
+            inContext: localContext,
+            inRootData: localRootData
+        });
+    }
+
+    return replaceStandardNode({
+        inNode: localNode,
+        inContext: localContext,
+        inRootData: localRootData
+    });
+};
+
+export const replace = (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 replaceNode({
+        inNode: localStructure,
+        inContext: localContext,
+        inRootData: localData
+    });
+};
+
+export default replace;

package/src/v10/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/v10/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/v10/instructionEngine/resolvePath.js

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

package/src/v10/instructionEngine/resolveTokenValue.js

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

package/src/v10/instructionEngine/story/storyInjector.js

@@ -0,0 +1,50 @@
+import { interpolateString } from "../value/interpolate.js";
+
+export const injectStory = (cloned, originalNode, currentItem, inRootData) => {
+    if (typeof originalNode.story !== "string" || originalNode.story.trim() === "") return cloned;
+
+    const storyText = interpolateString({
+        inText: originalNode.story,
+        inItemContext: currentItem,
+        inRootData
+    });
+
+    const storyTitle = typeof originalNode.storyTitle === "string" && originalNode.storyTitle.trim() !== ""
+        ? interpolateString({
+            inText: originalNode.storyTitle,
+            inItemContext: currentItem,
+            inRootData
+        })
+        : null;
+
+    const storyTag = (typeof originalNode.storyTag === "string" && originalNode.storyTag.trim() !== "") ? originalNode.storyTag : "p";
+    const storyClass = (typeof originalNode.storyClass === "string" && originalNode.storyClass.trim() !== "") ? originalNode.storyClass : "story text-muted small";
+    const storyPosition = originalNode.storyPosition === "append" ? "append" : "prepend";
+
+    const nextChildren = Array.isArray(cloned.children) ? cloned.children : [];
+    const storyNodes = [];
+
+    if (storyTitle) {
+        storyNodes.push({
+            tagName: "strong",
+            attributes: { class: "story-title d-block" },
+            textContent: storyTitle
+        });
+    }
+
+    storyNodes.push({
+        tagName: storyTag,
+        attributes: { class: storyClass },
+        textContent: storyText
+    });
+
+    if (storyPosition === "prepend") {
+        cloned.children = [...storyNodes, ...nextChildren];
+    } else {
+        cloned.children = [...nextChildren, ...storyNodes];
+    }
+
+    return cloned;
+};
+
+export default injectStory;

package/src/v10/instructionEngine/storyInjector.js

@@ -0,0 +1 @@
+export { injectStory, default } from "./story/storyInjector.js";

package/src/v10/instructionEngine/value/interpolate.js

@@ -0,0 +1,38 @@
+import { resolveTokenValue } from "../resolve/resolveTokenValue.js";
+
+export const interpolateValue = ({ inValue, inItemContext, inRootData }) => {
+    if (typeof inValue !== "string" || !inValue.includes("${")) {
+        return inValue;
+    }
+
+    const exactMatch = inValue.match(/^\$\{([^}]+)\}$/);
+    if (exactMatch) {
+        const token = resolveTokenValue({
+            inPath: exactMatch[1].trim(),
+            inItemContext,
+            inRootData
+        });
+        return token !== undefined && token !== null ? token : "";
+    }
+
+    return inValue.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+        const token = resolveTokenValue({
+            inPath: expr.trim(),
+            inItemContext,
+            inRootData
+        });
+        return token !== undefined && token !== null ? String(token) : "";
+    });
+};
+
+export const interpolateString = ({ inText, inItemContext, inRootData }) => {
+    const value = interpolateValue({
+        inValue: inText,
+        inItemContext,
+        inRootData
+    });
+
+    return value !== undefined && value !== null ? String(value) : "";
+};
+
+export default { interpolateValue, interpolateString };

package/src/v11/index.js

@@ -0,0 +1,116 @@
+/**
+ * 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, replaceNode } from "./replace.js";
+import { iterate, iterateNode, operation } from "./iterate.js";
+
+export const meta = {
+    version: "11.0.0",
+    name: "json-to-spec/v11",
+    description: "Minimalist 2-layer compiler: pure value replace + jsonToSpec iterate"
+};
+
+/**
+ * Executes a custom pipeline of transformations over the structure.
+ */
+export const pipeline = ({ inStructure, inData = {}, inSteps = [replace, iterate] } = {}) => {
+    const localData = inData;
+    const localSteps = inSteps;
+
+    let current = inStructure;
+    for (const step of localSteps) {
+        if (typeof step === "function") {
+            current = step({ inStructure: current, inData: localData });
+        }
+    }
+    return current;
+};
+
+export const pipe = (...inSteps) => {
+    const localSteps = inSteps.length > 0 ? inSteps : [replace, iterate];
+    return (inStructure, inData = {}) => {
+        return pipeline({ inStructure, inData, inSteps: localSteps });
+    };
+};
+
+/**
+ * Main compiler entry point:
+ * 1. Replace values: replace(structure, data)
+ * 2. Iterate/Operate: iterate(replacedStructure, data)
+ */
+export const compile = (inStructureOrOptions, inData = {}) => {
+    let localStructure = inStructureOrOptions;
+    let localData = inData;
+
+    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;
+        } else if ("structure" in inStructureOrOptions) {
+            localStructure = inStructureOrOptions.structure;
+            localData = inStructureOrOptions.data || localData;
+        }
+    }
+
+    // Step 1: Replace tokens in the structure
+    const replaced = replace({
+        inStructure: localStructure,
+        inData: localData
+    });
+
+    // Step 2: Expand jsonToSpec operations on the replaced structure
+    const spec = iterate({
+        inStructure: replaced,
+        inData: localData
+    });
+
+    // const spec = replace({
+    //     inStructure: localStructure,
+    //     inData: localData
+    // });
+
+    // const spec = iterate({
+    //     inStructure: localStructure,
+    //     inData: localData
+    // });
+
+
+    return spec;
+};
+
+export const jsonToSpec = {
+    replace,
+    iterate,
+    operation,
+    pipeline,
+    pipe,
+    compile
+};
+
+export {
+    replace,
+    replaceNode,
+    iterate,
+    iterateNode,
+    operation
+};
+
+if (typeof globalThis !== "undefined") {
+    globalThis.ks ??= {};
+    globalThis.ks["json-to-spec"] = {
+        meta,
+        compile,
+        replace,
+        iterate,
+        operation,
+        pipeline,
+        jsonToSpec
+    };
+}
+
+export default compile;