@nshiab/simple-data-analysis-core 0.0.12

package/script/helpers/printTable.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = printTable;
+const wrapString_js_1 = __importDefault(require("./wrapString.js"));
+/**
+ * Prints a formatted table to the console with support for word wrapping
+ * within cells. Unlike `console.table()`, this function properly handles
+ * multi-line content within cells, making it ideal for displaying data with
+ * long text values.
+ *
+ * @param data - An array of objects representing the rows of the table. Each
+ *   object should have string keys.
+ * @param options - Optional configuration for table rendering.
+ * @param options.maxColumnWidth - The maximum width for any column (default:
+ *   `75`). Values exceeding this width will be wrapped at word boundaries.
+ * @param options.minColumnWidth - The minimum width for any column (default:
+ *   `3`).
+ * @param options.typesRowIndex - The index of a row that contains type
+ *   annotations (e.g. `"VARCHAR/string"`). This row will be rendered in grey.
+ *   If omitted, no row is treated as a types row.
+ * @returns void - The table is printed directly to the console.
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { name: "Alice", description: "A software engineer with expertise in TypeScript" },
+ *   { name: "Bob", description: "A product manager" }
+ * ];
+ * printTable(data, { maxColumnWidth: 30 });
+ * // Outputs a nicely formatted table with word-wrapped description column
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With types row
+ * const types = { name: "VARCHAR/string", age: "INTEGER/number" };
+ * const data = [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob", age: 25 }
+ * ];
+ * printTable([types, ...data], { typesRowIndex: 0 });
+ * ```
+ */
+function printTable(data, options) {
+    if (!data || data.length === 0) {
+        console.log("(empty table)");
+        return;
+    }
+    const maxColumnWidth = options?.maxColumnWidth ?? 75;
+    const minColumnWidth = options?.minColumnWidth ?? 3;
+    // Helper function to format values for display
+    const formatValue = (value) => {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value);
+    };
+    // Get all column names
+    const columns = Object.keys(data[0]);
+    if (columns.length === 0) {
+        console.log("(empty table)");
+        return;
+    }
+    // Single pass: calculate column widths and prepare wrapped data.
+    // First, seed widths from header names.
+    const columnWidths = {};
+    for (const col of columns) {
+        columnWidths[col] = col.length;
+    }
+    // Format every cell, track the longest raw line per column, and
+    // store the formatted strings for the wrapping step that follows.
+    const formattedData = [];
+    for (const row of data) {
+        const formattedRow = [];
+        for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const value = formatValue(row[col]);
+            formattedRow.push(value);
+            // Track longest line (handles embedded newlines)
+            const lines = value.split("\n");
+            let longestLine = 0;
+            for (const line of lines) {
+                if (line.length > longestLine)
+                    longestLine = line.length;
+            }
+            if (longestLine > columnWidths[col]) {
+                columnWidths[col] = longestLine;
+            }
+        }
+        formattedData.push(formattedRow);
+    }
+    // Apply min/max constraints
+    for (const col of columns) {
+        columnWidths[col] = Math.min(Math.max(columnWidths[col], minColumnWidth), maxColumnWidth);
+    }
+    // Wrap pre-formatted strings into multi-line cells
+    const wrappedData = [];
+    for (let r = 0; r < formattedData.length; r++) {
+        const wrappedRow = {};
+        for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const value = formattedData[r][c];
+            const width = columnWidths[col];
+            // Split by existing newlines, then wrap each part
+            const lines = value.split("\n");
+            const allWrappedLines = [];
+            for (const line of lines) {
+                if (line.length <= width) {
+                    allWrappedLines.push(line);
+                }
+                else {
+                    // Wrap long lines at word boundaries
+                    const wrapped = (0, wrapString_js_1.default)(line, width);
+                    allWrappedLines.push(...wrapped.split("\n"));
+                }
+            }
+            wrappedRow[col] = allWrappedLines.length > 0 ? allWrappedLines : [""];
+        }
+        wrappedData.push(wrappedRow);
+    }
+    // ANSI color codes (matching Deno's console colors)
+    const colors = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        grey: "\x1b[90m",
+        string: "\x1b[32m", // green
+        number: "\x1b[33m", // yellow
+        boolean: "\x1b[95m", // bright magenta/pink
+        date: "\x1b[36m", // cyan
+        null: "\x1b[90m", // grey
+    };
+    // Helper function to get color for a value based on its actual JavaScript type
+    const getColorForValue = (value, isTypeRow) => {
+        if (isTypeRow)
+            return colors.grey;
+        if (value === null || value === undefined)
+            return colors.null;
+        if (value instanceof Date)
+            return colors.date;
+        if (typeof value === "boolean")
+            return colors.boolean;
+        if (typeof value === "number")
+            return colors.number;
+        return colors.string;
+    };
+    // Helper function to create a horizontal border line with column junctions
+    const createBorderLine = (left, middle, right) => {
+        const segments = columns.map((col) => "─".repeat(columnWidths[col] + 2));
+        return colors.grey + left + segments.join(middle) + right + colors.reset;
+    };
+    // Helper function to create a separator line
+    const createSeparator = () => createBorderLine("├", "┼", "┤");
+    // Helper function to create the top border
+    const createTopBorder = () => createBorderLine("┌", "┬", "┐");
+    // Helper function to create the bottom border
+    const createBottomBorder = () => createBorderLine("└", "┴", "┘");
+    // Helper function to pad a string to a specific width
+    const pad = (str, width) => {
+        return str + " ".repeat(Math.max(0, width - str.length));
+    };
+    // Print top border
+    console.log(createTopBorder());
+    // Print header row (bold)
+    const headerParts = columns.map((col) => ` ${colors.bold}${pad(col, columnWidths[col])}${colors.reset} `);
+    console.log(colors.grey + "│" + colors.reset +
+        headerParts.join(colors.grey + "│" + colors.reset) + colors.grey + "│" +
+        colors.reset);
+    // Detect if any row has word wrapping (spans multiple lines)
+    let hasWordWrapping = false;
+    for (const wrappedRow of wrappedData) {
+        for (const col of columns) {
+            if (wrappedRow[col].length > 1) {
+                hasWordWrapping = true;
+                break;
+            }
+        }
+        if (hasWordWrapping)
+            break;
+    }
+    // Print separator after header (unless the first row is the types row,
+    // in which case the separator is printed after the types row instead)
+    if (options?.typesRowIndex !== 0) {
+        console.log(createSeparator());
+    }
+    // Print data rows
+    for (let i = 0; i < wrappedData.length; i++) {
+        const wrappedRow = wrappedData[i];
+        const originalRow = data[i];
+        const isTypeRow = i === options?.typesRowIndex;
+        // Find the maximum number of lines in this row
+        let maxLines = 1;
+        for (const col of columns) {
+            if (wrappedRow[col].length > maxLines) {
+                maxLines = wrappedRow[col].length;
+            }
+        }
+        // Print each line of this row
+        for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+            const lineParts = columns.map((col) => {
+                const lines = wrappedRow[col];
+                const lineValue = lineIdx < lines.length ? lines[lineIdx] : "";
+                const color = getColorForValue(originalRow[col], isTypeRow);
+                return ` ${color}${pad(lineValue, columnWidths[col])}${colors.reset} `;
+            });
+            console.log(colors.grey + "│" + colors.reset +
+                lineParts.join(colors.grey + "│" + colors.reset) + colors.grey +
+                "│" +
+                colors.reset);
+        }
+        // Print separator after types row
+        if (isTypeRow) {
+            console.log(createSeparator());
+        } // Print separator between rows when word wrapping is present (except after last row)
+        else if (hasWordWrapping && i < wrappedData.length - 1) {
+            console.log(createSeparator());
+        }
+    }
+    // Print bottom border
+    console.log(createBottomBorder());
+}

package/script/helpers/queryDB.d.ts

@@ -0,0 +1,19 @@
+import SimpleTable from "../class/SimpleTable.js";
+import SimpleDB from "../class/SimpleDB.js";
+export default function queryDB(simple: SimpleTable | SimpleDB, query: string, options: {
+    table: string | null;
+    method: string | null;
+    parameters: {
+        [key: string]: unknown;
+    } | null;
+    nbRowsToLog: number;
+    nbCharactersToLog: number | undefined;
+    returnDataFrom: "query" | "none";
+    debug: boolean;
+    types?: {
+        [key: string]: string;
+    };
+}): Promise<{
+    [key: string]: string | number | boolean | Date | null;
+}[] | null>;
+//# sourceMappingURL=queryDB.d.ts.map

package/script/helpers/queryDB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryDB.d.ts","sourceRoot":"","sources":["../../src/helpers/queryDB.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,QAAQ,MAAM,sBAAsB,CAAC;AAG5C,wBAA8B,OAAO,CACnC,MAAM,EAAE,WAAW,GAAG,QAAQ,EAC9B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,cAAc,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACnC,GACA,OAAO,CACN;IACA,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;CACxD,EAAE,GACD,IAAI,CACP,CA+DA"}

package/script/helpers/queryDB.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queryDB;
+const SimpleTable_js_1 = __importDefault(require("../class/SimpleTable.js"));
+const SimpleDB_js_1 = __importDefault(require("../class/SimpleDB.js"));
+const cleanSQL_js_1 = __importDefault(require("./cleanSQL.js"));
+async function queryDB(simple, query, options) {
+    if (simple instanceof SimpleDB_js_1.default && simple.connection === undefined) {
+        await simple.start();
+    }
+    else if (simple instanceof SimpleTable_js_1.default &&
+        simple.connection === undefined) {
+        await simple.sdb.start();
+        simple.db = simple.sdb.db;
+        simple.connection = simple.sdb.connection;
+    }
+    if (simple.connection === undefined) {
+        throw new Error("simple.connection is undefined");
+    }
+    query = (0, cleanSQL_js_1.default)(query);
+    if (options.debug) {
+        // We beautify it a little bit
+        if (query.at(-1) !== ";") {
+            query += ";";
+        }
+        if (query.includes("\n")) {
+            query = query
+                .trim()
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line !== "" && line !== ";")
+                .join("\n");
+        }
+        console.log(query);
+    }
+    let data = null;
+    if (options.returnDataFrom === "none") {
+        await simple.runQuery(query, simple.connection, false, options);
+    }
+    else if (options.returnDataFrom === "query") {
+        data = await simple.runQuery(query, simple.connection, true, {
+            ...options,
+            // To convert dates and bigInts to numbers
+            types: options.method !== "getTypes()"
+                ? options.types
+                    ? options.types
+                    : simple instanceof SimpleTable_js_1.default
+                        ? await simple.getTypes()
+                        : undefined
+                : undefined,
+        });
+    }
+    else {
+        throw new Error(`Unknown ${options.returnDataFrom} options.returnDataFrom`);
+    }
+    if (options.returnDataFrom === "query") {
+        if (data === null) {
+            throw new Error("data is null");
+        }
+        return data;
+    }
+    else {
+        return null;
+    }
+}

package/script/helpers/rewind.d.ts

@@ -0,0 +1,3 @@
+declare function rewind(object2: any): any;
+export { rewind as default };
+//# sourceMappingURL=rewind.d.ts.map

package/script/helpers/rewind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.d.ts","sourceRoot":"","sources":["../../src/helpers/rewind.ts"],"names":[],"mappings":"AA0mCA,iBAAS,MAAM,CAAC,OAAO,KAAA,OAiBtB;AAiHD,OAAO,EACL,MAAM,IAAI,OAAO,EAClB,CAAC"}