@keshavsoft/kschema-cli 1.13.3 → 1.13.7

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/TableStore/V3/dataStore.js

@@ -0,0 +1,45 @@
+export const createDataStore = () => {
+    let data = [];
+    let searchConfig = { type: "global", value: "" };
+    let findData = {};
+    let dataLists = {};
+
+    return {
+        setData: (inData) => { data = inData; },
+        getData: () => data,
+        setSearchConfig: (config) => { searchConfig = config; },
+        getSearchConfig: () => searchConfig,
+        getFinalData: () => {
+            let result = [...data];
+            if (searchConfig.value || searchConfig.filters?.length) {
+                if (searchConfig.type === "global") {
+                    result = result.filter(row =>
+                        Object.values(row).some(val =>
+                            val != null && String(val).includes(searchConfig.value)
+                        )
+                    );
+                }
+                if (searchConfig.type === "column") {
+                    result = result.filter(row =>
+                        row[searchConfig.key] != null &&
+                        String(row[searchConfig.key]).includes(searchConfig.value)
+                    );
+                }
+                if (searchConfig.type === "multi") {
+                    result = result.filter(row =>
+                        searchConfig.filters.every(f =>
+                            row[f.key] != null &&
+                            String(row[f.key]).includes(f.value)
+                        )
+                    );
+                }
+            }
+            return result;
+        },
+        setFindData: (inData) => { findData = inData; },
+        getFindData: () => findData,
+        setDataList: (key, inData) => { dataLists[key] = inData; },
+        getDataList: (key) => dataLists[key],
+        getAllDataLists: () => dataLists,
+    };
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/TableStore/V3/metaStore.js

@@ -0,0 +1,15 @@
+export const createMetaStore = () => {
+    let tableName = "";
+    let defaultRow = {};
+    let toSaveRow = {};
+
+    return {
+        setDefaultRow: (row) => { defaultRow = row; },
+        getDefaultRow: () => defaultRow,
+        setTableName: (name) => { tableName = name; },
+        getTableName: () => tableName,
+        setToSaveRow: (row) => { toSaveRow = row; },
+        appendToSaveRow: (key, value) => { toSaveRow[key] = value; },
+        getToSaveRow: () => toSaveRow,
+    };
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/TableStore/V3/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/builders/buildDataListContainer.js

@@ -0,0 +1,6 @@
+export const buildDataListContainer = () => {
+    const container = document.createElement("div");
+    container.className = "dataListContainerClass";
+
+    return { container };
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/builders/buildHeaderRow.js

@@ -0,0 +1,77 @@
+export const buildHeaderRow = ({ inTitleText = "Items" } = {}) => {
+    const titleText = inTitleText;
+
+    const header = createHeaderRoot();
+    const left = createLeftSection({ inTitleText: titleText });
+    const right = createSearchSection();
+
+    header.append(left, right.container);
+
+    return { header, searchInput: right.input };
+};
+
+const createHeaderRoot = () => {
+    const el = document.createElement("div");
+    el.className = "firstRowClass flex items-center justify-between px-6 pt-2 pb-2";
+    return el;
+};
+const createLeftSection = ({ inTitleText }) => {
+    const titleText = inTitleText;
+
+    const left = document.createElement("div");
+    left.className = "flex items-center gap-3";
+
+    const title = document.createElement("h5");
+    title.className = "tableNameClass text-lg font-semibold text-gray-900";
+    title.textContent = titleText;
+
+    left.appendChild(title);
+
+    return left;
+};
+
+const createSearchSection = () => {
+    const container = document.createElement("div");
+    container.className = "relative w-full max-w-md";
+
+    const input = createSearchInput();
+    const icon = createSearchIcon();
+
+    container.append(input, icon);
+
+    return { container, input, icon };
+};
+const createSearchInput = () => {
+    const input = document.createElement("input");
+    input.type = "text";
+    input.placeholder = "search...";
+    input.className =
+        "tableSearchClass ks-search-allColumns w-full h-9 pl-3 pr-9 text-sm border border-gray-300 rounded-md outline-none";
+
+    return input;
+};
+const createSearchIcon = () => {
+    const input = document.createElement("input");
+
+    const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    svg.setAttribute("class", "absolute right-2 top-2 w-4 h-4 text-gray-400 cursor-pointer");
+    svg.setAttribute("fill", "none");
+    svg.setAttribute("stroke", "currentColor");
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("stroke-width", "2");
+    svg.setAttribute("stroke-linecap", "round");
+    svg.setAttribute("stroke-linejoin", "round");
+
+    const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+    path.setAttribute("d", "M21 21l-5.2-5.2M15 10a5 5 0 11-10 0 5 5 0 0110 0z");
+
+    svg.appendChild(path);
+
+    // ✅ CLICK EVENT
+    svg.addEventListener("click", () => {
+        input.focus();
+        input.dispatchEvent(new Event("input")); // trigger search manually if needed
+    });
+
+    return svg;
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/builders/buildTableShell.js

@@ -0,0 +1,21 @@
+export const buildTableShell = () => {
+    const wrapper = document.createElement("div");
+    wrapper.className = "rounded-b-lg shadow-md overflow-x-auto tableParent";
+
+    const table = document.createElement("table");
+    table.className = "table w-full bg-white";
+
+    const thead = document.createElement("thead");
+    thead.className = "theadClass";
+
+    const tbody = document.createElement("tbody");
+    tbody.className = "tbodyClass";
+
+    const tfoot = document.createElement("tfoot");
+    tfoot.className = "tfootClass";
+
+    table.append(thead, tbody, tfoot);
+    wrapper.append(table);
+
+    return { wrapper };
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/compose/buildFullUI.js

@@ -0,0 +1,36 @@
+import { buildHeaderRow } from "../builders/buildHeaderRow.js";
+import { buildDataListContainer } from "../builders/buildDataListContainer.js";
+import { buildTableShell } from "../builders/buildTableShell.js";
+
+export const buildFullUI1 = ({ containerEl, inTableName, inIsDataListNeeded = true }) => {
+    const root = containerEl;
+    root.className = "max-w-6xl mx-auto p-2";
+
+    const { header } = buildHeaderRow({ inTitleText: inTableName });
+    const { container: dataList } = buildDataListContainer();
+    const { wrapper } = buildTableShell();
+
+    root.replaceChildren(header, wrapper, dataList);
+};
+
+export const buildFullUI = ({ containerEl, inTableName, inIsDataListNeeded = true, inIsTableNeeded = true }) => {
+    const root = containerEl;
+    root.className = "max-w-6xl mx-auto p-2";
+
+    let children = [];
+
+    if (inIsTableNeeded) {
+        const { header } = buildHeaderRow({ inTitleText: inTableName });
+        const { wrapper } = buildTableShell();
+
+        children.push(header);
+        children.push(wrapper);
+    };
+
+    if (inIsDataListNeeded) {
+        const { container: dataList } = buildDataListContainer();
+        children.push(dataList);
+    };
+
+    root.replaceChildren(...children);
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/mountTableOnly.js

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

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/mountTableUI.js

@@ -0,0 +1,28 @@
+// /UI/mountTableUI.js
+
+// import { initRender } from "../BuildTotal/initRender.js";
+import { initRender } from "../BuildTableOnlyWithVersions/V5/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/UI/mountVertical.js

@@ -0,0 +1,30 @@
+import { initRender } from "../BuildVerticalWithVersions/V1/initRender.js";
+import { buildFullUI } from "./compose/buildFullUI.js";
+
+export const mountVerticalUI = ({
+    containerEl,
+    dataStore,
+    dom,
+    services,
+    options,
+    endPoints,
+    columnsConfig,
+    uiClasses,
+    callbacks,
+    inConfig
+}) => {
+    buildFullUI({ containerEl, inIsTableNeeded: false });
+
+    initRender({
+        inContainerEl: containerEl,
+        inDataStore: dataStore,
+        inDom: dom,
+        inServices: services,
+        inOptions: options,
+        inEndPoints: endPoints,
+        inColumnsConfig: columnsConfig,
+        inUiClasses: uiClasses,
+        callbacks,
+        inConfig
+    });
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/Utils/prepareColumnsBundle.js

@@ -0,0 +1,35 @@
+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 toSaveRow = 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,
+        toSaveRow
+    };
+};

package/bin/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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/V3/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);
+
+        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);
+        // console.log("aaaaa : ", bundle.dataListColumns);
+
+        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.dataStore.setToSaveRow(bundle.toSaveRow);
+
+        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/v13/commands/accounts/template/v9/Public/KSTableAi/V31/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;
+};