json-renderers 1.13.7 → 1.16.1

package/src/v15/registerGlobal.js

@@ -0,0 +1,14 @@
+import meta from "./meta.js";
+
+export const registerGlobal = (inFuncDefinition) => {
+    if (typeof globalThis === "undefined" || !inFuncDefinition) return;
+
+    globalThis.ks ??= {};
+
+    globalThis.ks.jsonRenderers ??= {
+        meta,
+        renderToDom: inFuncDefinition
+    };
+};
+
+export default registerGlobal;

package/src/v16/buildSpec/index.js

@@ -0,0 +1,40 @@
+import jsonRenderBuild from "json-renderers-build";
+import jsonToTag from "@keshavsoft/json-to-tag";
+
+// --- Story of Table Render ---
+const startFunc = ({
+    inTargetHtmlId,
+    inColumns,
+    inType = "table",
+    inData,
+    inShowLog = false
+} = {}) => {
+    const localTargetHtmlId = inTargetHtmlId;
+    const localData = inData ?? [];
+    const localColumns = inColumns;
+    const localType = inType;
+    const localShowLog = inShowLog;
+
+    if (localShowLog) console.log("buildSpec 1 :", localTargetHtmlId, localData, localColumns);
+
+    let specAsJsonToDom = jsonRenderBuild({
+        type: localType,
+        targetHtmlId: localTargetHtmlId,
+        data: localData,
+        columns: localColumns
+    });
+
+    let jsonToSend = specAsJsonToDom;
+
+    const content = jsonToTag(jsonToSend);
+
+    if (localShowLog) {
+        console.log("buildSpec 2 :", jsonToSend, content);
+        console.log("buildSpec 3 :", content);
+    }
+
+    return content;
+};
+
+export { startFunc };
+export default startFunc;

package/src/v16/common/deriveColumnsFromData.js

@@ -0,0 +1,20 @@
+const deriveColumnsFromData = ({ inData = [] } = {}) => {
+    const localData = inData;
+
+    if (!Array.isArray(localData) || localData.length === 0) {
+        return [];
+    }
+
+    const firstRow = localData[0];
+    if (!firstRow || typeof firstRow !== "object") {
+        return [];
+    }
+
+    return Object.keys(firstRow).map(key => ({
+        key,
+        label: key
+    }));
+};
+
+export { deriveColumnsFromData };
+export default deriveColumnsFromData;

package/src/v16/guard.js

@@ -0,0 +1,38 @@
+const guardFunc = ({ inConfig } = {}) => {
+    const localConfig = inConfig;
+
+    if (!localConfig || typeof localConfig !== "object") {
+        console.error("Config must be an object");
+        throw new TypeError("Config must be an object");
+    }
+
+    if (localConfig.type !== "table") {
+        console.error("type must be 'table'");
+        throw new Error("type must be 'table'");
+    }
+
+    if (!Array.isArray(localConfig.data)) {
+        console.error("data must be an Array");
+        throw new TypeError("data must be an Array");
+    }
+
+    if (typeof localConfig.targetHtmlId !== "string" || !localConfig.targetHtmlId.trim()) {
+        console.error("targetHtmlId must be a non-empty string");
+        throw new TypeError("targetHtmlId must be a non-empty string");
+    }
+
+    if (!Array.isArray(localConfig.columns)) {
+        console.error("columns must be an array");
+        throw new TypeError("columns must be an array");
+    }
+
+    if (localConfig.showLog !== undefined && typeof localConfig.showLog !== "boolean") {
+        console.error("showLog must be a boolean");
+        throw new TypeError("showLog must be a boolean");
+    }
+
+    return true;
+};
+
+export { guardFunc };
+export default guardFunc;

package/src/v16/index.js

@@ -0,0 +1,110 @@
+import registerGlobal from "./registerGlobal.js";
+import guardFunc from "./guard.js";
+import buildSpec from "./buildSpec/index.js";
+
+// Pure function: builds and validates the JSON configuration without touching DOM
+const getSpec = ({
+    type = "table",
+    targetHtmlId,
+    data,
+    columns,
+    classToApply,
+    appendPosition,
+    showLog = false
+} = {}) => {
+    const localType = type;
+    const localTargetHtmlId = targetHtmlId;
+    const localData = data;
+    const localColumns = columns;
+    const localClassToApply = classToApply;
+    const localAppendPosition = appendPosition;
+    const localShowLog = showLog;
+
+    const specJson = {
+        type: localType,
+        targetHtmlId: localTargetHtmlId,
+        data: localData,
+        columns: localColumns,
+        classToApply: localClassToApply,
+        appendPosition: localAppendPosition,
+        showLog: localShowLog
+    };
+
+    // Internal call using the in-convention
+    guardFunc({ inConfig: specJson });
+
+    return specJson;
+};
+
+// Render function: Public API accepting clean single options object
+const render = ({
+    type = "table",
+    targetHtmlId,
+    data,
+    columns,
+    classToApply,
+    appendPosition,
+    showLog = false
+} = {}) => {
+    // 1. Get and validate the clean JSON specification
+    const specJson = getSpec({
+        type,
+        targetHtmlId,
+        data,
+        columns,
+        classToApply,
+        appendPosition,
+        showLog
+    });
+
+    if (specJson.showLog) console.log("showLog 1 (spec):", specJson);
+
+    // 2. Build DOM content via buildSpec
+    const content = buildSpec({
+        inTargetHtmlId: specJson.targetHtmlId,
+        inColumns: specJson.columns,
+        inData: specJson.data,
+        inType: specJson.type,
+        inShowLog: specJson.showLog
+    });
+
+    if (specJson.showLog) console.log("showLog 2 (content):", content);
+
+    const container = document.getElementById(specJson.targetHtmlId);
+    if (specJson.showLog) console.log("showLog 3 (container):", container);
+
+    if (!container) return null;
+
+    const isCollection = Array.isArray(content) ||
+        content instanceof NodeList ||
+        content instanceof HTMLCollection;
+
+    if (isCollection) {
+        if (specJson.appendPosition === "prepend") {
+            container.prepend(...content);
+        } else {
+            container.append(...content);
+        }
+    } else {
+        if (specJson.appendPosition === "prepend") {
+            container.prepend(content);
+        } else {
+            container.innerHTML = "";
+            container.append(content);
+        }
+    }
+
+    if (specJson.showLog) console.log("showLog 4 (mounted):", container);
+
+    return container;
+};
+
+// Register on global window.ks.jsonRenderers
+registerGlobal({ render, getSpec });
+
+// Export two ways:
+// 1. As an object (named exports)
+export { render, getSpec, guardFunc, buildSpec };
+
+// 2. As a single function (default export)
+export default render;

package/src/v16/meta.js

@@ -0,0 +1,6 @@
+export const meta = {
+    version: "v16.0.0",
+    description: "build table from store data and render to DOM uses json-to-spec, json-to-dom under the hood"
+};
+
+export default meta;

package/src/v16/registerGlobal.js

@@ -0,0 +1,27 @@
+import meta from "./meta.js";
+
+export const registerGlobal = (inDefinition) => {
+    const localDefinition = inDefinition;
+
+    if (typeof globalThis === "undefined" || !localDefinition) return;
+
+    globalThis.ks ??= {};
+
+    const renderFunc = typeof localDefinition === "function"
+        ? localDefinition
+        : localDefinition.render;
+
+    const getSpecFunc = typeof localDefinition === "object"
+        ? localDefinition.getSpec
+        : undefined;
+
+    globalThis.ks.jsonRenderers = {
+        meta,
+        renderToDom: renderFunc,
+        render: renderFunc,
+        ...(getSpecFunc ? { getSpec: getSpecFunc } : {}),
+        ...(typeof localDefinition === "object" ? localDefinition : {})
+    };
+};
+
+export default registerGlobal;