@keshavsoft/kschema-cli 1.12.12 → 1.12.14

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/TableStore/V2/start.js

@@ -0,0 +1,9 @@
+import { createDataStore } from "./dataStore.js";
+import { createColumnStore } from "./columnStore.js";
+import { createMetaStore } from "./metaStore.js";
+
+export const createStore = () => ({
+    ...createDataStore(),
+    ...createColumnStore(),
+    ...createMetaStore()
+});

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/UI/mountTableOnly.js

@@ -0,0 +1,29 @@
+// /UI/mountTableUI.js
+
+import { initRender } from "../BuildTableOnly/initRender.js";
+
+export const mountTableOnlyUI = ({
+    containerEl,
+    dataStore,
+    dom,
+    services,
+    options,
+    endPoints,
+    columnsConfig,
+    uiClasses,
+    callbacks,
+    inConfig
+}) => {
+    initRender({
+        inContainerEl: containerEl,
+        inDataStore: dataStore,
+        inDom: dom,
+        inServices: services,
+        inOptions: options,
+        inEndPoints: endPoints,
+        inColumnsConfig: columnsConfig,
+        inUiClasses: uiClasses,
+        callbacks,
+        inConfig
+    });
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/UI/mountTableUI.js

@@ -0,0 +1,27 @@
+// /UI/mountTableUI.js
+
+import { initRender } from "../BuildTotal/initRender.js";
+
+export const mountTableUI = ({
+    containerEl,
+    dataStore,
+    dom,
+    services,
+    options,
+    endPoints,
+    columnsConfig,
+    uiClasses,
+    callbacks
+}) => {
+    initRender({
+        inContainerEl: containerEl,
+        inDataStore: dataStore,
+        inDom: dom,
+        inServices: services,
+        inOptions: options,
+        inEndPoints: endPoints,
+        inColumnsConfig: columnsConfig,
+        inUiClasses: uiClasses,
+        callbacks
+    });
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/UI/mountVertical.js

@@ -0,0 +1,29 @@
+// /UI/mountTableUI.js
+
+import { initRender } from "../BuildVertical/initRender.js";
+
+export const mountVerticalUI = ({
+    containerEl,
+    dataStore,
+    dom,
+    services,
+    options,
+    endPoints,
+    columnsConfig,
+    uiClasses,
+    callbacks,
+    inConfig
+}) => {
+    initRender({
+        inContainerEl: containerEl,
+        inDataStore: dataStore,
+        inDom: dom,
+        inServices: services,
+        inOptions: options,
+        inEndPoints: endPoints,
+        inColumnsConfig: columnsConfig,
+        inUiClasses: uiClasses,
+        callbacks,
+        inConfig
+    });
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/normalizeConfig.js

@@ -0,0 +1,27 @@
+const normalizeConfig = (cfg = {}) => {
+    cfg.options ??= {};
+    cfg.options.dataList ??= {};
+    cfg.options.dataList.show ??= false;
+
+    cfg.options.firstRow ??= {};
+    cfg.options.firstRow.showSearch ??= false;
+
+    cfg.options.table ??= {};
+    cfg.options.table.showFooter ??= false;
+    cfg.options.table.showRowOptions ??= false;
+    cfg.options.table.showSerial ??= false;
+    cfg.options.table.showTable ??= false;
+
+    cfg.options.table.footer ??= {};
+    cfg.options.table.footer.showDataList ??= false;
+
+    cfg.options.table.footer.showDataList ??= false;
+
+    cfg.options.vertical ??= {};
+    cfg.options.vertical ??= "";
+    cfg.options.isDisabled ??= "";
+
+    return cfg;
+};
+
+export { normalizeConfig };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/prepareColumnsBundle.js

@@ -0,0 +1,26 @@
+export const prepareColumnsBundle = (columnsConfig = []) => {
+    const keys = columnsConfig.map(c => c.columnName);
+
+    const visibleConfig = columnsConfig.filter(c => c.isVisible !== false);
+
+    const visibleColumns = visibleConfig.map(c => c.columnName);
+
+    const defaultRow = columnsConfig.reduce((acc, c) => {
+        if ("defaultValue" in c) {
+            acc[c.columnName] = c.defaultValue ?? "";
+        };
+
+        return acc;
+    }, {});
+
+    const dataListColumns = visibleConfig
+        .filter(c => c.tableFooterDataListShow);
+
+    return {
+        keys,
+        visibleColumns,
+        visibleConfig,
+        defaultRow,
+        dataListColumns
+    };
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/tableHelpers.js

@@ -0,0 +1,24 @@
+const prepareDefaultRow = (columnsConfig) => {
+    const row = {};
+
+    columnsConfig.forEach((col) => {
+        if (col.defaultValue !== undefined) {
+            row[col.columnName] = col.defaultValue;
+        }
+    });
+
+    return row;
+};
+
+const getColumnsMeta = (columnsConfig) => ({
+    columns: columnsConfig.map(c => c.columnName),
+    columnsConfig: columnsConfig.map(c => c.columnName),
+    visibleColumns: columnsConfig
+        .filter(c => c.isVisible !== false)
+        .map(c => c.columnName)
+});
+
+export {
+    prepareDefaultRow,
+    getColumnsMeta
+}

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/validateConfig.js

@@ -0,0 +1,16 @@
+// split into small validators
+import { validateRequired } from "./validateRequired.js";
+import { validateEndpoints } from "./validateEndpoints.js";
+import { validateOptions } from "./validateOptions.js";
+
+export const validateConfig = (cfg = {}) => {
+    const errors = [];
+
+    validateRequired(cfg, errors);
+    validateEndpoints(cfg, errors);
+    validateOptions(cfg, errors);
+
+    if (errors.length) {
+        throw new Error("Invalid initTable config:\n" + errors.join("\n"));
+    }
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/validateEndpoints.js

@@ -0,0 +1,12 @@
+const validateEndpoints = (cfg, errors) => {
+    if (!cfg.endPoints) return;
+
+    ["create", "update", "delete", "read"].forEach((k) => {
+        if (cfg.endPoints?.[k] && typeof cfg.endPoints[k] !== "string")
+            errors.push(`endPoints.${k} must be a string`);
+    });
+};
+
+export {
+    validateEndpoints
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/validateOptions.js

@@ -0,0 +1,21 @@
+const validateOptions = (cfg, errors) => {
+    if (!cfg.options) return;
+
+    const { vertical, table } = cfg.options;
+
+    if (vertical && "showVertical" in vertical && typeof vertical.showVertical !== "boolean") {
+        errors.push("options.vertical.showVertical must be boolean");
+    }
+
+    if (table) {
+        ["showRowOptions", "showFooter"].forEach((k) => {
+            if (k in table && typeof table[k] !== "boolean") {
+                errors.push(`options.table.${k} must be boolean`);
+            }
+        });
+    }
+};
+
+export {
+    validateOptions
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/Utils/validateRequired.js

@@ -0,0 +1,16 @@
+const validateRequired = (cfg, errors) => {
+    if (!cfg.containerId || typeof cfg.containerId !== "string")
+        errors.push("containerId is required (string)");
+
+    if (!cfg.tableName || typeof cfg.tableName !== "string")
+        errors.push("tableName is required (string)");
+
+    // ✅ allow either data OR read
+    const hasData = Array.isArray(cfg.data);
+    const hasRead = typeof cfg.endPoints?.read === "string";
+
+    if (!hasData && !hasRead)
+        errors.push("provide either data OR endPoints.read");
+};
+
+export { validateRequired };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/ai.js

@@ -0,0 +1,165 @@
+// ai.js
+import { createState } from "./HtmlState/start.js";
+import { getDomManipulation } from "./DomManipulation/start.js";
+import { validateConfig } from "./Utils/validateConfig.js";
+import { prepareColumnsBundle } from "./Utils/prepareColumnsBundle.js";
+import { normalizeConfig } from "./Utils/normalizeConfig.js";
+import { focusToEl } from "./FocusSet/V2/focusSet.js";
+
+import { createStore } from "./TableStore/V2/start.js";
+import { applyMode } from "./Core/applyMode.js";
+import { KeshavUIClasses } from "./uiClasses.js";
+import { loadDataFlow } from "./Core/loadDataFlow.js";
+import { loadVerticalOnly } from "./Core/loadVerticalOnly.js";
+
+import { setupServices } from "./Services/setupServices.js";
+import { mountTableUI } from "./UI/mountTableUI.js";
+import { mountVerticalUI } from "./UI/mountVertical.js";
+import { mountTableOnlyUI } from "./UI/mountTableOnly.js";
+
+class KSAiTable {
+    constructor(inConfig) {
+        let config = normalizeConfig(inConfig);
+        // config = applyMode(config);
+        // validateConfig(config);
+        // debugger;
+        const { containerId, options, endPoints, columnsConfig,
+            uiClasses, callbacks } = config;
+
+        this.config = config;
+        this.containerEl = document.getElementById(containerId);
+
+        if (!this.containerEl) {
+            throw new Error(`Container not found: ${containerId}`);
+        };
+
+        this.dataStore = createStore();
+        this.uiState = createState();
+        this.dom = getDomManipulation();
+
+        this.uiState.setTableContainerId(containerId);
+        this.uiClasses = this.mergeUI(KeshavUIClasses, uiClasses);
+
+        const bundle = prepareColumnsBundle(columnsConfig);
+
+        this.dataStore.setColumns(bundle.keys);
+        this.dataStore.setVisibleColumns(bundle.visibleColumns);
+        this.dataStore.setVisibleConfig(bundle.visibleConfig);
+        this.dataStore.setDefaultRow(bundle.defaultRow);
+        this.dataStore.setDataListColumns(bundle.dataListColumns);
+
+        this.options = options;
+        this.endPoints = endPoints;
+        this.columnsConfig = columnsConfig;
+        // constructor
+        this.callbacks = callbacks || {};
+    };
+
+    mergeUI(defaults, incoming = {}) {
+        return {
+            ...defaults,
+            ...incoming,
+            form: {
+                ...defaults.form,
+                ...incoming.form
+            }
+        };
+    };
+
+    async init() {
+        this.setupServices();
+
+        await loadDataFlow({
+            config: this.config,
+            services: this.services,
+            dataStore: this.dataStore,
+            endPoints: this.endPoints
+        });
+
+        this.mountUI();
+
+        focusToEl({
+            inContainerEl: this.containerEl,
+            inPriority: this.options.focus.priority
+        });
+    };
+
+    async initVertical() {
+        this.setupServices();
+
+        await loadDataFlow({
+            config: this.config,
+            services: this.services,
+            dataStore: this.dataStore,
+            endPoints: this.endPoints
+        });
+
+        this.mountVertical();
+    };
+
+    async initTable() {
+        this.setupServices();
+
+        await loadDataFlow({
+            config: this.config,
+            services: this.services,
+            dataStore: this.dataStore,
+            endPoints: this.endPoints
+        });
+
+        this.mountTableOnly();
+    };
+
+    setupServices() {
+        this.services = setupServices({
+            config: this.config,
+            dataStore: this.dataStore
+        });
+    };
+
+    mountUI() {
+        mountTableUI({
+            containerEl: this.containerEl,
+            dataStore: this.dataStore,
+            dom: this.dom,
+            services: this.services,
+            options: this.options,
+            endPoints: this.endPoints,
+            columnsConfig: this.columnsConfig,
+            uiClasses: this.uiClasses,
+            callbacks: this.callbacks
+        });
+    };
+
+    mountVertical() {
+        mountVerticalUI({
+            containerEl: this.containerEl,
+            dataStore: this.dataStore,
+            dom: this.dom,
+            services: this.services,
+            options: this.options,
+            endPoints: this.endPoints,
+            columnsConfig: this.columnsConfig,
+            uiClasses: this.uiClasses,
+            callbacks: this.callbacks,
+            inConfig: this.config,
+        });
+    };
+    
+    mountTableOnly() {
+        mountTableOnlyUI({
+            containerEl: this.containerEl,
+            dataStore: this.dataStore,
+            dom: this.dom,
+            services: this.services,
+            options: this.options,
+            endPoints: this.endPoints,
+            columnsConfig: this.columnsConfig,
+            uiClasses: this.uiClasses,
+            callbacks: this.callbacks,
+            inConfig: this.config,
+        });
+    };
+};
+
+export { KSAiTable };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/entry.js

@@ -0,0 +1,23 @@
+import { KSAiTable } from "./ai.js";
+
+// entry.js
+export const initTable = async (cfg) => {
+    // debugger;
+    const table = new KSAiTable(cfg);
+    await table.init();   // ✅ THIS is missing
+    return table;
+};
+
+export const initVertical = async (cfg) => {
+    // debugger;
+    const table = new KSAiTable(cfg);
+    await table.initVertical();   // ✅ THIS is missing
+    return table;
+};
+
+export const initTableOnly = async (cfg) => {
+    // debugger;
+    const table = new KSAiTable(cfg);
+    await table.initTable();   // ✅ THIS is missing
+    return table;
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/tableStore.js

@@ -0,0 +1,79 @@
+export const createStore = () => {
+    let data = [];
+    let keys = [];
+    let searchConfig = { type: "global", value: "" };
+    let tableName = "";
+    let visibleColumns = [];
+
+    let defaultRow = {};
+
+    return {
+        setDefaultRow: (row) => {
+            defaultRow = row;
+        },
+        getDefaultRow: () => {
+            return defaultRow;
+        },
+        setData(inData) {
+            data = inData;
+            // keys = Object.keys(inData[0] || {});
+        },
+        setColumns: (cfg) => {
+            keys = cfg.map(c => c.columnName);
+            visibleColumns = cfg.filter(c => c.isVisible !== false).map(c => c.columnName);
+        },
+        setSearchConfig(config) {
+            searchConfig = config;
+        },
+        getSearchConfig(config) {
+            return searchConfig;
+        },
+        getData() {
+            return data;
+        },
+        getColumns() {
+            return keys;
+        },
+        getVisibleColumns() {
+            return visibleColumns;
+        },
+        getTableName() {
+            return tableName;
+        },
+        setTableName(inTableName) {
+            tableName = inTableName;
+        },
+        getFinalData() {
+            let result = [...data];
+
+            if (searchConfig.value || searchConfig.filters?.length) {
+                if (searchConfig.type === "global") {
+                    result = result.filter(row =>
+                        Object.values(row).some(val =>
+                            val !== undefined && val !== null &&
+                            String(val).includes(searchConfig.value)
+                        )
+                    );
+                }
+
+                if (searchConfig.type === "column") {
+                    result = result.filter(row =>
+                        row[searchConfig.key] !== undefined &&
+                        String(row[searchConfig.key]).includes(searchConfig.value)
+                    );
+                }
+
+                if (searchConfig.type === "multi") {
+                    result = result.filter(row =>
+                        searchConfig.filters.every(f =>
+                            row[f.key] !== undefined &&
+                            String(row[f.key]).includes(f.value)
+                        )
+                    );
+                }
+            };
+
+            return result;
+        }
+    };
+};

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V22/uiClasses.js

@@ -0,0 +1,22 @@
+const KeshavUIClasses = {
+    form1: {
+        formClass: 'mb-4 p-4 border rounded verticalForm',
+        inputClass: 'border px-2 py-1 flex-1',
+        buttonClass: 'mt-2 px-4 py-1 bg-green-500 text-white',
+        rowClass: 'flex items-center gap-4 mb-2',
+        labelClass: 'w-40',
+    },
+    form: {
+        formClass: 'grid grid-cols-1 gap-x-8 gap-y-4 p-6 verticalForm',
+        buttonClass: 'mt-2 px-4 py-1 bg-green-500 text-white',
+        rowClass: 'flex items-center space-x-4',
+        labelClass: 'w-24 text-sm font-medium',
+        inputClass: 'flex-1 border rounded px-3 py-2'
+    },
+    table: {
+        tdClass: "px-4 py-2 border",
+        serialClass: "px-4 py-2 border"
+    }
+};
+
+export { KeshavUIClasses };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/assemble.js

@@ -0,0 +1,6 @@
+const assembleHeader = (wrapper, text, icon) => {
+    wrapper.appendChild(text);
+    wrapper.appendChild(icon);
+};
+
+export { assembleHeader };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/createSortIcon.js

@@ -0,0 +1,25 @@
+const createSortIcon = () => {
+    const svgNS = "http://www.w3.org/2000/svg";
+
+    const svg = document.createElementNS(svgNS, "svg");
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("fill", "none");
+    svg.setAttribute("stroke", "currentColor");
+    svg.setAttribute("stroke-width", "2");
+    svg.setAttribute("class", "w-4 h-4 text-gray-400");
+    svg.setAttribute("data-sort-icon", "true");
+
+    const path = document.createElementNS(svgNS, "path");
+    path.setAttribute("stroke-linecap", "round");
+    path.setAttribute("stroke-linejoin", "round");
+    path.setAttribute(
+        "d",
+        "M8.25 15L12 18.75 15.75 15m-7.5-6L12 5.25 15.75 9"
+    );
+
+    svg.appendChild(path);
+
+    return svg;
+};
+
+export { createSortIcon };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/createTH.js

@@ -0,0 +1,12 @@
+const createTH = (key) => {
+    const th = document.createElement("th");
+
+    th.className =
+        "px-6 py-3 text-left border-b border-gray-200 bg-gray-50 hover:bg-gray-100 transition-colors cursor-pointer";
+
+    th.dataset.key = key;
+
+    return th;
+};
+
+export { createTH };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/createText.js

@@ -0,0 +1,7 @@
+const createText = (key) => {
+    const span = document.createElement("span");
+    span.textContent = key;
+    return span;
+};
+
+export { createText };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/createWrapper.js

@@ -0,0 +1,14 @@
+import { createText } from "./createText.js";
+import { createSortIcon } from "./createSortIcon.js";
+
+const createWrapper = (key) => {
+    const div = document.createElement("div");
+    div.className = "flex items-center gap-1 text-base font-bold text-gray-800";
+
+    div.appendChild(createText(key));
+    div.appendChild(createSortIcon());
+
+    return div;
+};
+
+export { createWrapper };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/CreateHeaderCell/start.js

@@ -0,0 +1,15 @@
+import { createTH } from "./createTH.js";
+import { createWrapper } from "./createWrapper.js";
+
+const createHeaderCell = (key) => {
+    const th = createTH(key);
+
+    const wrapper = createWrapper(key);
+
+    // attach to TH
+    th.appendChild(wrapper);
+
+    return th;
+};
+
+export { createHeaderCell };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/insertCells.js

@@ -0,0 +1,9 @@
+import { createHeaderCell } from "./CreateHeaderCell/start.js";
+
+const startFunc = (keys, tr, options = {}) => {
+    keys.forEach(key => {
+        tr.appendChild(createHeaderCell(key));
+    });
+};
+
+export { startFunc };

package/bin/v12/commands/tally/template/v4/Public/KSTableAi/V23/BuildHeader/CreateHeaderRow/start.js

@@ -0,0 +1,21 @@
+import { startFunc as insertRowCells } from "./insertCells.js";
+
+const startFunc = (keys) => {
+    const tr = document.createElement("tr");
+
+    tr.appendChild(getSerialColumn());
+
+    insertRowCells(keys, tr);
+
+    return tr;
+};
+
+const getSerialColumn = () => {
+    const thIndex = document.createElement("th");
+    thIndex.textContent = "#";
+    thIndex.className = "px-4 py-2 border";
+
+    return thIndex
+};
+
+export { startFunc };