@nshiab/simple-data-analysis-core 2.1.12 → 2.1.13

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

@@ -1 +0,0 @@
-{"version":3,"file":"prepareUmapLayoutOptions.d.ts","sourceRoot":"","sources":["../../src/helpers/prepareUmapLayoutOptions.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CACrB;;;;;;EA2BP"}

package/script/helpers/prepareUmapLayoutOptions.js

@@ -1,29 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareUmapLayoutOptions;
-const fitUmapCurve_js_1 = __importDefault(require("./fitUmapCurve.js"));
-// Resolve and validate settings before database work, fitting the curve once.
-function prepareUmapLayoutOptions(options = {}) {
-    const { epochs = 200, seed = 42, minDistance = 0.1, learningRate = 1, negativeSamples = 5, } = options;
-    for (const [key, value] of Object.entries({ epochs, negativeSamples })) {
-        if (!Number.isSafeInteger(value) || value < 1) {
-            throw new Error(`${key} must be a positive safe integer.`);
-        }
-    }
-    if (!Number.isInteger(seed) || seed < 0 || seed > 0xffffffff) {
-        throw new Error("seed must be an integer between 0 and 4294967295.");
-    }
-    if (!Number.isFinite(learningRate) || learningRate <= 0) {
-        throw new Error("learningRate must be finite and positive.");
-    }
-    return {
-        epochs,
-        seed,
-        learningRate,
-        negativeSamples,
-        curve: (0, fitUmapCurve_js_1.default)(minDistance),
-    };
-}

package/script/helpers/prepareValueFilters.d.ts

@@ -1,11 +0,0 @@
-import type { DuckDBValue } from "@duckdb/node-api";
-export type ValueFilter = {
-    column: string;
-    values: DuckDBValue[];
-    includesNull: boolean;
-};
-/** Converts column filter values to bindable values while tracking nulls. */
-export default function prepareValueFilters(columnsAndValues: {
-    [key: string]: unknown;
-}): ValueFilter[];
-//# sourceMappingURL=prepareValueFilters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prepareValueFilters.d.ts","sourceRoot":"","sources":["../../src/helpers/prepareValueFilters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,6EAA6E;AAC7E,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,gBAAgB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAC3C,WAAW,EAAE,CAWf"}

package/script/helpers/prepareValueFilters.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = prepareValueFilters;
-const toDuckDBValue_js_1 = __importDefault(require("./toDuckDBValue.js"));
-/** Converts column filter values to bindable values while tracking nulls. */
-function prepareValueFilters(columnsAndValues) {
-    return Object.entries(columnsAndValues).map(([column, value]) => {
-        const boundValues = (Array.isArray(value) ? value : [value]).map(toDuckDBValue_js_1.default);
-        return {
-            column,
-            values: boundValues.filter((boundValue) => boundValue !== null),
-            includesNull: boundValues.some((boundValue) => boundValue === null),
-        };
-    });
-}

package/script/helpers/prettyDuration.d.ts

@@ -1,61 +0,0 @@
-/**
- * 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.
- *
- * @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"
- * ```
- *
- * @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.
- *
- * @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

@@ -1 +0,0 @@
-{"version":3,"file":"prettyDuration.d.ts","sourceRoot":"","sources":["../../src/helpers/prettyDuration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;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

@@ -1,154 +0,0 @@
-"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.
- *
- * @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"
- * ```
- *
- * @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.
- *
- * @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

@@ -1,55 +0,0 @@
-/**
- * Prints a formatted table to the console with support for word wrapping
- * within headers and cells. Unlike `console.table()`, this function properly
- * handles multi-line content, making it ideal for displaying data with long
- * column names and text values.
- * Widths count graphemes, keeping combining accents with their letters. Wide
- * characters and emoji are not measured by their terminal display width.
- *
- * @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 });
- * ```
- *
- * @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`). Headers and 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.
- */
-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

@@ -1 +0,0 @@
-{"version":3,"file":"printTable.d.ts","sourceRoot":"","sources":["../../src/helpers/printTable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;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,CAqNN"}

package/script/helpers/printTable.js

@@ -1,230 +0,0 @@
-"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 LogValue_js_1 = __importDefault(require("./LogValue.js"));
-const splitGraphemes_js_1 = __importDefault(require("./splitGraphemes.js"));
-const wrapString_js_1 = __importDefault(require("./wrapString.js"));
-/**
- * Prints a formatted table to the console with support for word wrapping
- * within headers and cells. Unlike `console.table()`, this function properly
- * handles multi-line content, making it ideal for displaying data with long
- * column names and text values.
- * Widths count graphemes, keeping combining accents with their letters. Wide
- * characters and emoji are not measured by their terminal display width.
- *
- * @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 });
- * ```
- *
- * @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`). Headers and 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.
- */
-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 LogValue_js_1.default)
-            return value.text;
-        if (value instanceof Date) {
-            return Number.isNaN(value.getTime())
-                ? "Invalid Date"
-                : 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] = Math.max(...col.split("\n").map((line) => (0, splitGraphemes_js_1.default)(line).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) {
-                const length = (0, splitGraphemes_js_1.default)(line).length;
-                if (length > longestLine)
-                    longestLine = 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);
-    }
-    // Use the same newline and word wrapping rules for headers and cells.
-    const wrapCell = (value, width) => {
-        const lines = value.split("\n").flatMap((line) => (0, splitGraphemes_js_1.default)(line).length <= width
-            ? [line]
-            : (0, wrapString_js_1.default)(line, width).split("\n"));
-        return lines.length > 0 ? lines : [""];
-    };
-    const wrappedHeaders = columns.map((col) => wrapCell(col, columnWidths[col]));
-    const wrappedData = formattedData.map((row) => Object.fromEntries(columns.map((col, c) => [
-        col,
-        wrapCell(row[c], columnWidths[col]),
-    ])));
-    // 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 instanceof LogValue_js_1.default)
-            return colors[value.category];
-        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 - (0, splitGraphemes_js_1.default)(str).length));
-    };
-    // Print top border
-    console.log(createTopBorder());
-    // Print each header line in bold, padding shorter headers to the same height.
-    const headerHeight = Math.max(...wrappedHeaders.map((lines) => lines.length));
-    for (let lineIdx = 0; lineIdx < headerHeight; lineIdx++) {
-        const headerParts = columns.map((col, c) => ` ${colors.bold}${pad(wrappedHeaders[c][lineIdx] ?? "", 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/publishPreparedColumns.d.ts

@@ -1,37 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-import type { PreparedNumericFeatures } from "./prepareNumericFeatures.js";
-type PublicationOutput = {
-    /** Raw output-column name. */
-    name: string;
-    /** Trusted internal SQL evaluated with the prepared relation aliased as p. */
-    expression: string;
-    /** Raw source-column name to replace in its original position. */
-    replace?: string;
-};
-type PublicationResult = {
-    /** Raw relation name joined to the prepared rows. */
-    relation: string;
-    /** Raw row-identity column in the result relation. */
-    rowIdColumn: string;
-};
-/**
- * Publishes validated algorithm outputs from a prepared numeric
- * feature snapshot. New outputs are appended, while replacements retain the
- * source column's position. Existing native DuckDB indexes are recreated after
- * table replacement because CREATE OR REPLACE drops them.
- *
- * Output expressions are trusted internal SQL. They may reference `p`, the
- * prepared relation alias, and `r` when a result relation is supplied. The
- * consumer must fully compute and validate one result row per prepared row
- * before calling this helper, and remains responsible for scratch cleanup.
- */
-export default function publishPreparedColumns(table: SimpleTable, prepared: Pick<PreparedNumericFeatures, "relation" | "rowIdColumn" | "sourceColumns" | "sourceTemporary">, options: {
-    method: string;
-    parameters: {
-        [key: string]: unknown;
-    } | null;
-    outputs: PublicationOutput[];
-    result?: PublicationResult;
-}): Promise<void>;
-export {};
-//# sourceMappingURL=publishPreparedColumns.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"publishPreparedColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/publishPreparedColumns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAM3E,KAAK,iBAAiB,GAAG;IACvB,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAA8B,sBAAsB,CAClD,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,IAAI,CACZ,uBAAuB,EACrB,UAAU,GACV,aAAa,GACb,eAAe,GACf,iBAAiB,CACpB,EACD,OAAO,EAAE;IACP,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9C,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B,GACA,OAAO,CAAC,IAAI,CAAC,CA0Ef"}