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

package/esm/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/esm/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/esm/helpers/prettyDuration.js

@@ -1,151 +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, 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

@@ -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/esm/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/esm/helpers/printTable.js

@@ -1,224 +0,0 @@
-import LogValue from "./LogValue.js";
-import splitGraphemes from "./splitGraphemes.js";
-import wrapString from "./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.
- */
-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 LogValue)
-            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) => splitGraphemes(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 = splitGraphemes(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) => splitGraphemes(line).length <= width
-            ? [line]
-            : wrapString(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)
-            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 - splitGraphemes(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/esm/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;
-};
-/**
- * Atomically 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 in
- * the same transaction 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/esm/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,CAwFf"}

package/esm/helpers/publishPreparedColumns.js

@@ -1,113 +0,0 @@
-import foldIdentifier from "./foldIdentifier.js";
-import mergeOptions from "./mergeOptions.js";
-import queryDB from "./queryDB.js";
-import quoteIdentifier from "./quoteIdentifier.js";
-/**
- * Atomically 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 in
- * the same transaction 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 async function publishPreparedColumns(table, prepared, options) {
-    validateOutputs(prepared.sourceColumns, options.outputs);
-    const connection = table.connection;
-    const q = quoteIdentifier;
-    const source = q(table.name);
-    const tableDetails = (await connection.runAndReadAll(`SELECT table_oid FROM duckdb_tables()
-     WHERE translate(table_name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') = $1
-       AND schema_name = current_schema()
-       AND database_name IN (current_database(), 'temp')
-       AND temporary = $2
-     LIMIT 1`, [foldIdentifier(table.name), prepared.sourceTemporary])).getRowsJS()[0];
-    if (tableDetails === undefined) {
-        throw new Error(`${options.method} requires a materialized source table.`);
-    }
-    const tableOid = tableDetails[0];
-    if (typeof tableOid !== "number" && typeof tableOid !== "bigint") {
-        throw new Error(`${options.method} could not identify the source table.`);
-    }
-    const indexes = (await connection.runAndReadAll("SELECT sql FROM duckdb_indexes() WHERE table_oid = $1 ORDER BY index_name", [tableOid])).getRowsJS().map((row) => String(row[0]));
-    const replacements = new Map(options.outputs.filter((output) => output.replace !== undefined).map((output) => [foldIdentifier(output.replace), output]));
-    const select = prepared.sourceColumns.map((column) => {
-        const replacement = replacements.get(foldIdentifier(column));
-        return replacement === undefined
-            ? `p.${q(column)}`
-            : `${replacement.expression} AS ${q(column)}`;
-    });
-    for (const output of options.outputs) {
-        if (output.replace === undefined) {
-            select.push(`${output.expression} AS ${q(output.name)}`);
-        }
-    }
-    const resultJoin = options.result === undefined
-        ? ""
-        : ` JOIN ${q(options.result.relation)} r
-      ON p.${q(prepared.rowIdColumn)} = r.${q(options.result.rowIdColumn)}`;
-    await connection.run("BEGIN TRANSACTION");
-    try {
-        await queryDB(table, `CREATE OR REPLACE ${prepared.sourceTemporary ? "TEMP " : ""}TABLE ${source} AS
-       SELECT ${select.join(", ")}
-       FROM ${q(prepared.relation)} p${resultJoin}
-       ORDER BY p.${q(prepared.rowIdColumn)}`, mergeOptions(table, {
-            table: table.name,
-            method: options.method,
-            parameters: options.parameters,
-            noClean: true,
-        }));
-        for (const sql of indexes) {
-            try {
-                await connection.run(sql);
-            }
-            catch (error) {
-                const detail = error instanceof Error ? ` ${error.message}` : "";
-                throw new Error(`${options.method} could not restore an existing DuckDB index while publishing its output. Remove or rebuild indexes that do not support the output column types.${detail}`, { cause: error });
-            }
-        }
-        await connection.run("COMMIT");
-    }
-    catch (error) {
-        try {
-            await connection.run("ROLLBACK");
-        }
-        catch {
-            // DuckDB may already abort the transaction after an index-build error.
-            // Preserve the publication error that explains why the operation failed.
-        }
-        // UNIQUE violations can be deferred until COMMIT, which may also fail for
-        // unrelated reasons. Preserve that diagnostic instead of blaming indexes.
-        throw error;
-    }
-}
-function validateOutputs(sourceColumns, outputs) {
-    const outputNames = new Set();
-    const replacements = new Set();
-    for (const output of outputs) {
-        const outputName = foldIdentifier(output.name);
-        if (outputNames.has(outputName)) {
-            throw new Error(`Internal publication received duplicate output column ${quoteIdentifier(output.name)}.`);
-        }
-        outputNames.add(outputName);
-        if (output.replace === undefined) {
-            if (sourceColumns.some((column) => foldIdentifier(column) === outputName)) {
-                throw new Error(`Internal publication cannot append existing column ${quoteIdentifier(output.name)}.`);
-            }
-            continue;
-        }
-        const replacement = foldIdentifier(output.replace);
-        if (outputName !== replacement) {
-            throw new Error(`Internal publication output ${quoteIdentifier(output.name)} must match its replacement column ${quoteIdentifier(output.replace)}.`);
-        }
-        if (!sourceColumns.some((column) => foldIdentifier(column) === replacement)) {
-            throw new Error(`Internal publication cannot replace missing column ${quoteIdentifier(output.replace)}.`);
-        }
-        if (replacements.has(replacement)) {
-            throw new Error(`Internal publication received duplicate replacement column ${quoteIdentifier(output.replace)}.`);
-        }
-        replacements.add(replacement);
-    }
-}