@keshavsoft/kschema-cli 1.12.14 → 1.12.16

package/bin/v12/commands/tally/template/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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 };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildHeader/attachSortHandlers.js

@@ -0,0 +1,38 @@
+import { setSort } from "../tableStore.js";
+import { buildTableBody } from "../methods.js";
+import { updateHeaderUI } from "./updateHeaderUI.js";
+import { startFunc as getTHead } from "./getTHead.js";
+
+/**
+ * Handles what should happen when a user clicks a column header
+ * Flow:
+ * 1. Update sort state
+ * 2. Rebuild table body based on new sort
+ * 3. Reflect UI changes in header (active column + direction)
+ */
+const handleHeaderSort = (headerCell) => {
+    const key = headerCell.dataset.key;
+
+    setSort(key);
+    buildTableBody();
+    updateHeaderUI(headerCell, key);
+};
+const getSortableHeaders = () => {
+    return getTHead().querySelectorAll("th[data-key]");
+};
+
+/**
+ * Attaches sorting behavior to a header row (<tr>)
+ * Every <th data-key> becomes clickable and triggers sorting
+ */
+const attachSortHandlers = () => {
+    const sortableHeaders = getSortableHeaders();
+
+    sortableHeaders.forEach(headerCell => {
+        headerCell.addEventListener("click", (e) => {
+            handleHeaderSort(e.currentTarget);
+        });
+    });
+};
+
+export { attachSortHandlers };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildHeader/getTHead.js

@@ -0,0 +1,12 @@
+import { getHtmlId } from "../tableStore.js";
+
+const startFunc = () => {
+    const tableContainerId = getHtmlId();
+    const tableContainer = document.getElementById(tableContainerId);
+
+    const thead = tableContainer.querySelector("table thead");
+
+    return thead;
+};
+
+export { startFunc };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildHeader/sortData.js

@@ -0,0 +1,16 @@
+const startFunc = (key, dataRef, sortState) => {
+    const asc = sortState[key] = !sortState[key];
+
+    dataRef.sort((a, b) => {
+        const valA = (a[key] ?? '').toString().toLowerCase();
+        const valB = (b[key] ?? '').toString().toLowerCase();
+
+        return asc
+            ? valA.localeCompare(valB)
+            : valB.localeCompare(valA);
+    });
+
+    return asc;
+};
+
+export { startFunc };

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

@@ -0,0 +1,9 @@
+import { startFunc as createHeaderRow } from "./CreateHeaderRow/start.js";
+
+const startFunc = ({ inColumns, inTableHeader }) => {
+    const tr = createHeaderRow(inColumns);
+
+    inTableHeader.appendChild(tr);
+};
+
+export { startFunc };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildHeader/updateHeaderUI.js

@@ -0,0 +1,49 @@
+import { getSortState } from "../tableStore.js";
+import { startFunc as getTHead } from "./getTHead.js";
+
+const ICON_DEFAULT = "M8.25 15L12 18.75 15.75 15m-7.5-6L12 5.25 15.75 9";
+const ICON_UP = "M5 15l7-7 7 7";
+const ICON_DOWN = "M19 9l-7 7-7-7";
+
+const getIconPath = (th) => {
+    return th.querySelector("[data-sort-icon] path");
+};
+
+// 🔹 Reset one column
+const resetColumn = (th) => {
+    const path = getIconPath(th);
+    if (!path) return;
+
+    path.setAttribute("d", ICON_DEFAULT);
+
+    th.classList.remove("text-gray-900");
+    th.classList.add("text-gray-700");
+};
+
+// 🔹 Activate one column
+const activateColumn = (th, asc) => {
+    const path = getIconPath(th);
+    if (!path) return;
+
+    path.setAttribute("d", asc ? ICON_UP : ICON_DOWN);
+
+    th.classList.remove("text-gray-700");
+    th.classList.add("text-gray-900");
+};
+
+// 🔹 Orchestration (NOW READABLE)
+const updateHeaderUI = (activeTh, key) => {
+    const { key: activeKey, asc } = getSortState();
+
+    // 1. Reset everything
+    const tableHead = getTHead();
+
+    tableHead.querySelectorAll("th[data-key]").forEach(resetColumn);
+
+    // 2. Activate selected
+    if (activeKey === key) {
+        activateColumn(activeTh, asc);
+    }
+};
+
+export { updateHeaderUI };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildTableOnly/AddListeners/start.js

@@ -0,0 +1,15 @@
+import { funcToRun as funcToRunFortableSearch } from "./tableSearch/start.js";
+
+const hookAllListeners = ({ inContainerEl, inDataStore, inDom, inOptions }) => {
+    const columns = inDataStore.getColumns();
+    const visibleColumns = inDataStore.getVisibleColumns();
+
+    funcToRunFortableSearch({
+        inContainerEl, inDataStore,
+        inDom, inColumns: columns,
+        inVisibleColumns: visibleColumns,
+        inOptions
+    });
+};
+
+export { hookAllListeners };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildTableOnly/AddListeners/tableSearch/atThatState.js

@@ -0,0 +1,23 @@
+import { buildRows } from './orchestrator.js';
+
+const buildBodyAtThatState = ({
+    inColumns,
+    inDataToShow,
+    inContainerEl,
+    inDom,
+    searchValue = ""
+}) => {
+
+    const tableBody = inDom.getTableBody(inContainerEl);
+    tableBody.innerHTML = '';
+
+    const rows = buildRows({
+        data: inDataToShow,
+        columns: inColumns,
+        searchValue
+    });
+
+    rows.forEach(tr => tableBody.appendChild(tr));
+};
+
+export { buildBodyAtThatState };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildTableOnly/AddListeners/tableSearch/createCell.js

@@ -0,0 +1,12 @@
+import { highlightText } from "./highlight.js";
+
+const createCell = ({ value, searchValue }) => {
+    const td = document.createElement('td');
+    td.className = 'px-4 py-2 border';
+
+    td.innerHTML = highlightText(value, searchValue);
+
+    return td;
+};
+
+export { createCell };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildTableOnly/AddListeners/tableSearch/createRow.js

@@ -0,0 +1,35 @@
+import { createCell } from './createCell.js';
+
+const createIndexCell = (index) => {
+    const td = document.createElement('td');
+    td.className = 'px-4 py-2 border text-right';
+    td.textContent = index + 1;
+    return td;
+};
+
+const createDataCells = ({ item, columns, searchValue }) => {
+    return columns.map(k => {
+        const value = (item[k] ?? '').toString();
+
+        return createCell({
+            value,
+            searchValue
+        });
+    });
+};
+
+const createRow = ({ item, columns, index, searchValue }) => {
+    const tr = document.createElement('tr');
+    tr.className = 'border-t hover:bg-blue-100 odd:bg-gray-100';
+
+    // 1. index column
+    tr.appendChild(createIndexCell(index));
+
+    // 2. data columns
+    const cells = createDataCells({ item, columns, searchValue });
+    cells.forEach(td => tr.appendChild(td));
+
+    return tr;
+};
+
+export { createRow };

package/bin/v12/commands/tally/template/v6/Public/KSTableAi/V23/BuildTableOnly/AddListeners/tableSearch/highlight.js

@@ -0,0 +1,14 @@
+const escapeRegex = (str) => {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+
+const highlightText = (text, search) => {
+    if (!search) return text;
+
+    const safeSearch = escapeRegex(search);
+    const regex = new RegExp(`(${safeSearch})`, "gi");
+
+    return text.replace(regex, `<span class="bg-yellow-300">$1</span>`);
+};
+
+export { highlightText };