@nshiab/simple-data-analysis-core 0.0.12

package/esm/helpers/mergeOptions.js

@@ -0,0 +1,12 @@
+export default function mergeOptions(simple, options) {
+    return {
+        table: options.table,
+        method: options.method,
+        parameters: options.parameters,
+        nbRowsToLog: options.nbRowsToLog ?? simple.nbRowsToLog,
+        nbCharactersToLog: simple.nbCharactersToLog,
+        returnDataFrom: options.returnDataFrom ?? "none",
+        debug: options.debug ?? simple.debug,
+        types: options.types,
+    };
+}

package/esm/helpers/nestQuery.d.ts

@@ -0,0 +1,2 @@
+export default function nestQuery(table: string, column: string, separator: string, categories: string | string[]): string;
+//# sourceMappingURL=nestQuery.d.ts.map

package/esm/helpers/nestQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/nestQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,UAc9B"}

package/esm/helpers/nestQuery.js

@@ -0,0 +1,13 @@
+import stringToArray from "./stringToArray.js";
+export default function nestQuery(table, column, separator, categories) {
+    const cats = stringToArray(categories);
+    const groupBy = cats.map((d) => `"${d}"`).join(", ");
+    const selectColumns = `${groupBy}, `;
+    const orderBy = `\nORDER BY ${cats.map((d) => `"${d}" ASC`).join(", ")}`;
+    const query = `CREATE OR REPLACE TABLE "${table}" AS
+SELECT
+  ${selectColumns}STRING_AGG("${column}", '${separator}') AS "${column}"
+FROM "${table}"
+GROUP BY ${groupBy}${orderBy};`;
+    return query;
+}

package/esm/helpers/parseDuckDBType.d.ts

@@ -0,0 +1,2 @@
+export default function parseDuckDBType(type: string): import("@duckdb/node-api").DuckDBIntegerType | import("@duckdb/node-api").DuckDBBigIntType | import("@duckdb/node-api").DuckDBDoubleType | import("@duckdb/node-api").DuckDBVarCharType | import("@duckdb/node-api").DuckDBTimestampType | import("@duckdb/node-api").DuckDBTimestampTZType | import("@duckdb/node-api").DuckDBDateType | import("@duckdb/node-api").DuckDBTimeType | import("@duckdb/node-api").DuckDBBooleanType | import("@duckdb/node-api").DuckDBArrayType;
+//# sourceMappingURL=parseDuckDBType.d.ts.map

package/esm/helpers/parseDuckDBType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDuckDBType.d.ts","sourceRoot":"","sources":["../../src/helpers/parseDuckDBType.ts"],"names":[],"mappings":"AAcA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,IAAI,EAAE,MAAM,mdA0BnD"}

package/esm/helpers/parseDuckDBType.js

@@ -0,0 +1,38 @@
+import { ARRAY, BIGINT, BOOLEAN, DATE, DOUBLE, FLOAT, INTEGER, TIME, TIMESTAMP, TIMESTAMPTZ, VARCHAR, } from "@duckdb/node-api";
+export default function parseDuckDBType(type) {
+    if (type === "INTEGER") {
+        return INTEGER;
+    }
+    else if (type === "BIGINT") {
+        return BIGINT;
+    }
+    else if (type === "DOUBLE") {
+        return DOUBLE;
+    }
+    else if (type === "VARCHAR") {
+        return VARCHAR;
+    }
+    else if (type === "TIMESTAMP") {
+        return TIMESTAMP;
+    }
+    else if (type === "TIMESTAMP WITH TIME ZONE") {
+        return TIMESTAMPTZ;
+    }
+    else if (type === "DATE") {
+        return DATE;
+    }
+    else if (type === "TIME") {
+        return TIME;
+    }
+    else if (type === "BOOLEAN") {
+        return BOOLEAN;
+    }
+    else if (type.includes("FLOAT[")) {
+        // For embeddings
+        const size = type.replace("FLOAT[", "").replace("]", "");
+        return ARRAY(FLOAT, parseInt(size));
+    }
+    else {
+        throw new Error(`Type ${type} not supported.`);
+    }
+}

package/esm/helpers/parseTypes.d.ts

@@ -0,0 +1,2 @@
+export default function parseType(type: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean" | "geometry"): string;
+//# sourceMappingURL=parseTypes.d.ts.map

package/esm/helpers/parseTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTypes.d.ts","sourceRoot":"","sources":["../../src/helpers/parseTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,IAAI,EACA,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,UAAU,UA+Bf"}

package/esm/helpers/parseTypes.js

@@ -0,0 +1,35 @@
+export default function parseType(type) {
+    const typeLowerCase = type.toLowerCase();
+    if (typeLowerCase === "integer") {
+        return "INTEGER";
+    }
+    else if (typeLowerCase === "float" || typeLowerCase === "number") {
+        return "DOUBLE";
+    }
+    else if (typeLowerCase === "string") {
+        return "VARCHAR";
+    }
+    else if (typeLowerCase === "datetime") {
+        return "TIMESTAMP";
+    }
+    else if (typeLowerCase === "datetimetz") {
+        return "TIMESTAMP WITH TIME ZONE";
+    }
+    else if ([
+        "date",
+        "time",
+        "bigint",
+        "hugeint",
+        "double",
+        "varchar",
+        "timestamp",
+        "timestamp with time zone",
+        "boolean",
+        "geometry",
+    ].includes(typeLowerCase)) {
+        return type.toUpperCase();
+    }
+    else {
+        throw new Error(`Unknown type ${type}`);
+    }
+}

package/esm/helpers/parseValue.d.ts

@@ -0,0 +1,2 @@
+export default function parseValue(value: unknown): string | boolean | number;
+//# sourceMappingURL=parseValue.d.ts.map

package/esm/helpers/parseValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseValue.d.ts","sourceRoot":"","sources":["../../src/helpers/parseValue.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAc5E"}

package/esm/helpers/parseValue.js

@@ -0,0 +1,20 @@
+export default function parseValue(value) {
+    if (Number.isNaN(value) || value === undefined || value === null) {
+        return "NULL";
+    }
+    else if (value instanceof Date) {
+        return `'${value.toISOString()}'`;
+    }
+    else if (typeof value === "string") {
+        return `'${value.replaceAll("'", "''")}'`;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    else if (typeof value === "number") {
+        return value;
+    }
+    else {
+        throw new Error(`Unkown type ${typeof value} of ${value}`);
+    }
+}

package/esm/helpers/prettyDuration.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Formats a duration into a human-readable string, breaking it down into years, months, days, hours, minutes, seconds, and milliseconds. This function is useful for displaying elapsed time in a user-friendly format, such as for performance logging, task completion times, or general time tracking.
+ *
+ * The function can calculate the duration from a given start time to the current time, or between a specified start and end time. It provides options for logging the output directly to the console and adding custom prefixes or suffixes to the formatted string. Note that for simplicity, months are approximated as 30 days and years as 365 days.
+ *
+ * @param start - The starting point of the duration. This can be a `Date` object or a Unix timestamp (number of milliseconds since epoch).
+ * @param options - Optional settings to customize the duration formatting and output.
+ *   @param options.log - If `true`, the formatted duration string will be logged to the console. Defaults to `false`.
+ *   @param options.end - The ending point of the duration. This can be a `Date` object or a Unix timestamp. If omitted, the current time (`Date.now()`) will be used as the end point.
+ *   @param options.prefix - A string to prepend to the formatted duration string (e.g., "Elapsed time: ").
+ *   @param options.suffix - A string to append to the formatted duration string (e.g., " (Task completed)").
+ * @returns A human-readable string representing the duration.
+ *
+ * @example
+ * ```ts
+ * // A starting Date somewhere in your code.
+ * const startDate = new Date(); // or Date.now()
+ *
+ * // When you want to know the elapsed duration, pass the start date.
+ * const duration = prettyDuration(startDate);
+ * console.log(duration); // Returns something like "22 days, 6 h, 3 min, 15 sec, 3 ms"
+ * ```
+ * @example
+ * ```ts
+ * // If you want to console.log it directly, set the `log` option to `true`.
+ * // This will print the duration to the console and also return the string.
+ * const startDateForLog = new Date();
+ * // ... some operations ...
+ * prettyDuration(startDateForLog, { log: true });
+ * ```
+ * @example
+ * ```ts
+ * // You can also use a prefix and/or suffix for the output string.
+ * const startDateWithPrefixSuffix = new Date();
+ * // ... some operations ...
+ * prettyDuration(startDateWithPrefixSuffix, { log: true, prefix: "Elapsed time: ", suffix: " (Main function)" });
+ * // Returns and logs something like "Total duration: 3 min, 15 sec, 3 ms (Main function)"
+ * ```
+ * @example
+ * ```ts
+ * // If you want to format the duration between two specific dates, use the `end` option.
+ * const start = new Date("2024-01-01T17:00:00Z");
+ * const end = new Date("2024-01-23T23:03:15Z");
+ * const specificDuration = prettyDuration(start, { end });
+ * console.log(specificDuration); // Returns "22 days, 6 h, 3 min, 15 sec, 0 ms"
+ * ```
+ * @category Formatting
+ */
+export default function prettyDuration(start: Date | number, options?: {
+    log?: boolean;
+    end?: Date | number;
+    prefix?: string;
+    suffix?: string;
+}): string;
+//# sourceMappingURL=prettyDuration.d.ts.map

package/esm/helpers/prettyDuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettyDuration.d.ts","sourceRoot":"","sources":["../../src/helpers/prettyDuration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE,IAAI,GAAG,MAAM,EACpB,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,MAAM,CAuGR"}

package/esm/helpers/prettyDuration.js

@@ -0,0 +1,145 @@
+/**
+ * Formats a duration into a human-readable string, breaking it down into years, months, days, hours, minutes, seconds, and milliseconds. This function is useful for displaying elapsed time in a user-friendly format, such as for performance logging, task completion times, or general time tracking.
+ *
+ * The function can calculate the duration from a given start time to the current time, or between a specified start and end time. It provides options for logging the output directly to the console and adding custom prefixes or suffixes to the formatted string. Note that for simplicity, months are approximated as 30 days and years as 365 days.
+ *
+ * @param start - The starting point of the duration. This can be a `Date` object or a Unix timestamp (number of milliseconds since epoch).
+ * @param options - Optional settings to customize the duration formatting and output.
+ *   @param options.log - If `true`, the formatted duration string will be logged to the console. Defaults to `false`.
+ *   @param options.end - The ending point of the duration. This can be a `Date` object or a Unix timestamp. If omitted, the current time (`Date.now()`) will be used as the end point.
+ *   @param options.prefix - A string to prepend to the formatted duration string (e.g., "Elapsed time: ").
+ *   @param options.suffix - A string to append to the formatted duration string (e.g., " (Task completed)").
+ * @returns A human-readable string representing the duration.
+ *
+ * @example
+ * ```ts
+ * // A starting Date somewhere in your code.
+ * const startDate = new Date(); // or Date.now()
+ *
+ * // When you want to know the elapsed duration, pass the start date.
+ * const duration = prettyDuration(startDate);
+ * console.log(duration); // Returns something like "22 days, 6 h, 3 min, 15 sec, 3 ms"
+ * ```
+ * @example
+ * ```ts
+ * // If you want to console.log it directly, set the `log` option to `true`.
+ * // This will print the duration to the console and also return the string.
+ * const startDateForLog = new Date();
+ * // ... some operations ...
+ * prettyDuration(startDateForLog, { log: true });
+ * ```
+ * @example
+ * ```ts
+ * // You can also use a prefix and/or suffix for the output string.
+ * const startDateWithPrefixSuffix = new Date();
+ * // ... some operations ...
+ * prettyDuration(startDateWithPrefixSuffix, { log: true, prefix: "Elapsed time: ", suffix: " (Main function)" });
+ * // Returns and logs something like "Total duration: 3 min, 15 sec, 3 ms (Main function)"
+ * ```
+ * @example
+ * ```ts
+ * // If you want to format the duration between two specific dates, use the `end` option.
+ * const start = new Date("2024-01-01T17:00:00Z");
+ * const end = new Date("2024-01-23T23:03:15Z");
+ * const specificDuration = prettyDuration(start, { end });
+ * console.log(specificDuration); // Returns "22 days, 6 h, 3 min, 15 sec, 0 ms"
+ * ```
+ * @category Formatting
+ */
+export default function prettyDuration(start, options = {}) {
+    if (start instanceof Date) {
+        start = start.getTime();
+    }
+    let end;
+    if (options.end instanceof Date) {
+        end = options.end.getTime();
+    }
+    else if (typeof options.end === "number") {
+        end = options.end;
+    }
+    else {
+        end = Date.now();
+    }
+    const differenceInMs = end - start;
+    let prettyDuration = "";
+    if (differenceInMs < 1000) {
+        // Less than a second
+        prettyDuration = `${differenceInMs} ms`;
+    }
+    else if (differenceInMs < 60_000) {
+        // Less than a minute
+        const sec = Math.floor(differenceInMs / 1000);
+        const ms = differenceInMs % 1000;
+        prettyDuration = `${sec} sec, ${ms} ms`;
+    }
+    else if (differenceInMs < 3_600_000) {
+        // Less than an hour
+        const min = Math.floor(differenceInMs / 60_000);
+        const remainingMs = differenceInMs % 60_000;
+        const sec = Math.floor(remainingMs / 1000);
+        const ms = remainingMs % 1000;
+        prettyDuration = `${min} min, ${sec} sec, ${ms} ms`;
+    }
+    else if (differenceInMs < 86_400_000) {
+        // Less than a day
+        const hours = Math.floor(differenceInMs / 3_600_000);
+        const remainingMsAfterHours = differenceInMs % 3_600_000;
+        const min = Math.floor(remainingMsAfterHours / 60_000);
+        const remainingMsAfterMinutes = remainingMsAfterHours % 60_000;
+        const sec = Math.floor(remainingMsAfterMinutes / 1000);
+        const ms = remainingMsAfterMinutes % 1000;
+        prettyDuration = `${hours} h, ${min} min, ${sec} sec, ${ms} ms`;
+    }
+    else if (differenceInMs < 2_592_000_000) {
+        // Less than a month
+        const days = Math.floor(differenceInMs / 86_400_000);
+        const remainingMsAfterDays = differenceInMs % 86_400_000;
+        const hours = Math.floor(remainingMsAfterDays / 3_600_000);
+        const remainingMsAfterHours = remainingMsAfterDays % 3_600_000;
+        const min = Math.floor(remainingMsAfterHours / 60_000);
+        const remainingMsAfterMin = remainingMsAfterHours % 60_000;
+        const sec = Math.floor(remainingMsAfterMin / 1000);
+        const ms = remainingMsAfterMin % 1000;
+        prettyDuration = `${days} ${days <= 1 ? "day" : "days"}, ${hours} h, ${min} min, ${sec} sec, ${ms} ms`;
+    }
+    else if (differenceInMs < 31_536_000_000) {
+        // Less than a year
+        const months = Math.floor(differenceInMs / 2_592_000_000);
+        const remainingMsAfterMonths = differenceInMs % 2_592_000_000;
+        const days = Math.floor(remainingMsAfterMonths / 86_400_000);
+        const remainingMsAfterDays = differenceInMs % 86_400_000;
+        const hours = Math.floor(remainingMsAfterDays / 3_600_000);
+        const remainingMsAfterHours = remainingMsAfterDays % 3_600_000;
+        const min = Math.floor(remainingMsAfterHours / 60_000);
+        const remainingMsAfterMin = remainingMsAfterHours % 60_000;
+        const sec = Math.floor(remainingMsAfterMin / 1000);
+        const ms = remainingMsAfterMin % 1000;
+        prettyDuration = `${months} ${months <= 1 ? "month" : "months"}, ${days} ${days <= 1 ? "day" : "days"}, ${hours} h, ${min} min, ${sec} sec, ${ms} ms`;
+    }
+    else {
+        // More than a year
+        const years = Math.floor(differenceInMs / 31_536_000_000);
+        const remainingMsAfterYears = differenceInMs % 31_536_000_000;
+        const months = Math.floor(remainingMsAfterYears / 2_592_000_000);
+        const remainingMsAfterMonths = differenceInMs % 2_592_000_000;
+        const days = Math.floor(remainingMsAfterMonths / 86_400_000);
+        const remainingMsAfterDays = differenceInMs % 86_400_000;
+        const hours = Math.floor(remainingMsAfterDays / 3_600_000);
+        const remainingMsAfterHours = remainingMsAfterDays % 3_600_000;
+        const min = Math.floor(remainingMsAfterHours / 60_000);
+        const remainingMsAfterMin = remainingMsAfterHours % 60_000;
+        const sec = Math.floor(remainingMsAfterMin / 1000);
+        const ms = remainingMsAfterMin % 1000;
+        prettyDuration = `${years} ${years <= 1 ? "year" : "years"}, ${months} ${months <= 1 ? "month" : "months"}, ${days} ${days <= 1 ? "day" : "days"}, ${hours} h, ${min} min, ${sec} sec, ${ms} ms`;
+    }
+    if (typeof options.prefix === "string") {
+        prettyDuration = `${options.prefix}${prettyDuration}`;
+    }
+    if (typeof options.suffix === "string") {
+        prettyDuration = `${prettyDuration}${options.suffix}`;
+    }
+    if (options.log === true) {
+        console.log(prettyDuration);
+    }
+    return prettyDuration;
+}

package/esm/helpers/printTable.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 });
+ * ```
+ */
+export default function printTable(data: {
+    [key: string]: unknown;
+}[], options?: {
+    maxColumnWidth?: number;
+    minColumnWidth?: number;
+    typesRowIndex?: number;
+}): void;
+//# sourceMappingURL=printTable.d.ts.map

package/esm/helpers/printTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printTable.d.ts","sourceRoot":"","sources":["../../src/helpers/printTable.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,OAAO,CAAC,EAAE;IACR,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACA,IAAI,CAuNN"}

package/esm/helpers/printTable.js

@@ -0,0 +1,217 @@
+import wrapString from "./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 });
+ * ```
+ */
+export default 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 = wrapString(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/esm/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/esm/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"}