@nshiab/simple-data-analysis-core 0.0.12

package/script/helpers/keepNumericalColumns.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = keepNumericalColumns;
+function keepNumericalColumns(types) {
+    const columns = [];
+    for (const col of Object.keys(types)) {
+        if (["FLOAT", "DOUBLE", "DECIMAL"].includes(types[col]) ||
+            types[col].includes("INT")) {
+            columns.push(col);
+        }
+    }
+    if (columns.length === 0) {
+        throw new Error("No numerical columns");
+    }
+    return columns;
+}

package/script/helpers/logData.d.ts

@@ -0,0 +1,6 @@
+export default function logData(types: {
+    [key: string]: string;
+} | null, data: {
+    [key: string]: string | number | boolean | Date | null;
+}[] | null, nbCharactersToLog?: number): void;
+//# sourceMappingURL=logData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logData.d.ts","sourceRoot":"","sources":["../../src/helpers/logData.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,IAAI,EACvC,IAAI,EACA;IACA,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;CACxD,EAAE,GACD,IAAI,EACR,iBAAiB,CAAC,EAAE,MAAM,QAwD3B"}

package/script/helpers/logData.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logData;
+const printTable_js_1 = __importDefault(require("./printTable.js"));
+function logData(types, data, nbCharactersToLog) {
+    if (data === null) {
+        console.log("Data is null");
+    }
+    else {
+        if (data.length === 0) {
+            console.log(data);
+        }
+        else {
+            const dataToBeLogged = [];
+            const keys = Object.keys(data[0]);
+            for (let i = 0; i < data.length; i++) {
+                const newItem = {};
+                for (const key of keys) {
+                    if (typeof nbCharactersToLog === "number" &&
+                        typeof data[i][key] === "string" &&
+                        data[i][key].length > nbCharactersToLog) {
+                        newItem[key] = data[i][key].slice(0, nbCharactersToLog) + "...";
+                    }
+                    else {
+                        newItem[key] = data[i][key];
+                    }
+                }
+                dataToBeLogged.push(newItem);
+            }
+            let hasTypesRow = false;
+            if (types !== null) {
+                const columns = Object.keys(types);
+                if (columns.length > 0) {
+                    for (const col of columns) {
+                        types[col] = types[col] + "/" +
+                            (data[0][col] === null ? null : typeof data[0][col]);
+                    }
+                    // Add types as the first row
+                    dataToBeLogged.unshift(types);
+                    hasTypesRow = true;
+                }
+            }
+            (0, printTable_js_1.default)(dataToBeLogged, {
+                ...(typeof nbCharactersToLog === "number"
+                    ? { maxColumnWidth: nbCharactersToLog }
+                    : {}),
+                ...(hasTypesRow ? { typesRowIndex: 0 } : {}),
+            });
+        }
+    }
+}

package/script/helpers/mergeOptions.d.ts

@@ -0,0 +1,28 @@
+import type Simple from "../class/Simple.js";
+export default function mergeOptions(simple: Simple, options: {
+    table: string | null;
+    method: string | null;
+    parameters: {
+        [key: string]: unknown;
+    } | null;
+    nbRowsToLog?: number;
+    returnDataFrom?: "query" | "none";
+    debug?: boolean;
+    types?: {
+        [key: string]: string;
+    };
+}): {
+    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;
+    };
+};
+//# sourceMappingURL=mergeOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeOptions.d.ts","sourceRoot":"","sources":["../../src/helpers/mergeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAE7C,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,MAAM,EACd,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,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACnC,GACA;IACD,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,CAWA"}

package/script/helpers/mergeOptions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mergeOptions;
+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/script/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/script/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/script/helpers/nestQuery.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = nestQuery;
+const stringToArray_js_1 = __importDefault(require("./stringToArray.js"));
+function nestQuery(table, column, separator, categories) {
+    const cats = (0, stringToArray_js_1.default)(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/script/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/script/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/script/helpers/parseDuckDBType.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseDuckDBType;
+const node_api_1 = require("@duckdb/node-api");
+function parseDuckDBType(type) {
+    if (type === "INTEGER") {
+        return node_api_1.INTEGER;
+    }
+    else if (type === "BIGINT") {
+        return node_api_1.BIGINT;
+    }
+    else if (type === "DOUBLE") {
+        return node_api_1.DOUBLE;
+    }
+    else if (type === "VARCHAR") {
+        return node_api_1.VARCHAR;
+    }
+    else if (type === "TIMESTAMP") {
+        return node_api_1.TIMESTAMP;
+    }
+    else if (type === "TIMESTAMP WITH TIME ZONE") {
+        return node_api_1.TIMESTAMPTZ;
+    }
+    else if (type === "DATE") {
+        return node_api_1.DATE;
+    }
+    else if (type === "TIME") {
+        return node_api_1.TIME;
+    }
+    else if (type === "BOOLEAN") {
+        return node_api_1.BOOLEAN;
+    }
+    else if (type.includes("FLOAT[")) {
+        // For embeddings
+        const size = type.replace("FLOAT[", "").replace("]", "");
+        return (0, node_api_1.ARRAY)(node_api_1.FLOAT, parseInt(size));
+    }
+    else {
+        throw new Error(`Type ${type} not supported.`);
+    }
+}

package/script/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/script/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/script/helpers/parseTypes.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseType;
+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/script/helpers/parseValue.d.ts

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

package/script/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/script/helpers/parseValue.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseValue;
+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/script/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/script/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/script/helpers/prettyDuration.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prettyDuration;
+/**
+ * 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
+ */
+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/script/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/script/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"}