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

package/esm/methods/loadYahooFinanceData.js

@@ -1,133 +0,0 @@
-import SDAError from "../class/SDAError.js";
-import queueOp from "../helpers/queueOp.js";
-import { executePreparedArray, prepareArray } from "./loadArray.js";
-const INTERVAL_SECONDS = {
-    "1d": 24 * 60 * 60,
-    "1h": 60 * 60,
-    "1m": 60,
-};
-const COLUMN_TYPES = {
-    datetime: "TIMESTAMP",
-    open: "DOUBLE",
-    high: "DOUBLE",
-    low: "DOUBLE",
-    close: "DOUBLE",
-    adjustedClose: "DOUBLE",
-    volume: "DOUBLE",
-};
-const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
-export default function loadYahooFinanceData(table, symbol, startDate, endDate, interval) {
-    assertArguments(symbol, startDate, endDate, interval);
-    const request = {
-        symbol,
-        startDate: new Date(startDate),
-        endDate: new Date(endDate),
-        interval,
-    };
-    queueOp(table, {
-        kind: "barrier",
-        method: "loadYahooFinanceData()",
-        parameters: request,
-        execute: () => executeLoadYahooFinanceData(table, request),
-    });
-}
-async function executeLoadYahooFinanceData(table, request) {
-    try {
-        const rows = await getYahooFinanceData(request);
-        await executePreparedArray(table, prepareArray(rows, COLUMN_TYPES));
-    }
-    catch (error) {
-        if (error instanceof SDAError) {
-            throw error;
-        }
-        throw new SDAError({
-            method: "loadYahooFinanceData()",
-            parameters: request,
-            query: "",
-            cause: error,
-        });
-    }
-}
-async function getYahooFinanceData(request) {
-    const { symbol, startDate, endDate, interval } = request;
-    const startTime = startDate.getTime();
-    const exclusiveEndTime = getExclusiveEndTime(endDate, interval);
-    const url = new URL(`https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(symbol)}`);
-    url.search = new URLSearchParams({
-        includeAdjustedClose: "true",
-        interval,
-        period1: String(Math.floor(startTime / 1000)),
-        period2: String(Math.ceil(exclusiveEndTime / 1000)),
-    }).toString();
-    const response = await fetch(url, {
-        headers: { "User-Agent": USER_AGENT },
-    });
-    if (!response.ok) {
-        const text = (await response.text()).slice(0, 500).trim();
-        throw new Error(`Failed to fetch Yahoo Finance data: ${response.status} ${response.statusText}${text.length > 0 ? `. ${text}` : ""}. Yahoo may have changed, rate-limited, or disabled this undocumented endpoint.`);
-    }
-    const data = await response.json();
-    if (data.chart?.error) {
-        throw new Error(data.chart.error.description ??
-            "Yahoo Finance returned an unknown error.");
-    }
-    const result = data.chart?.result?.[0];
-    const timestamps = result?.timestamp;
-    if (!result || !timestamps?.length) {
-        throw new Error("No Yahoo Finance data found.");
-    }
-    const quote = result.indicators?.quote?.[0];
-    const adjustedClose = result.indicators?.adjclose?.[0]?.adjclose;
-    const rows = [];
-    for (let index = 0; index < timestamps.length; index++) {
-        const timestamp = timestamps[index] * 1000;
-        if (Number.isFinite(timestamp) && timestamp >= startTime &&
-            timestamp < exclusiveEndTime) {
-            rows.push({
-                datetime: new Date(timestamp),
-                open: getFiniteValue(quote?.open, index),
-                high: getFiniteValue(quote?.high, index),
-                low: getFiniteValue(quote?.low, index),
-                close: getFiniteValue(quote?.close, index),
-                adjustedClose: getFiniteValue(adjustedClose, index),
-                volume: getFiniteValue(quote?.volume, index),
-            });
-        }
-    }
-    if (rows.length === 0) {
-        throw new Error(`No Yahoo Finance data found for ${symbol}.`);
-    }
-    return rows;
-}
-function getFiniteValue(values, index) {
-    const value = values?.[index];
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function getExclusiveEndTime(endDate, interval) {
-    const end = new Date(endDate);
-    if (interval === "1d") {
-        end.setUTCHours(0, 0, 0, 0);
-    }
-    else if (interval === "1h") {
-        end.setUTCMinutes(0, 0, 0);
-    }
-    else {
-        end.setUTCSeconds(0, 0);
-    }
-    return end.getTime() + INTERVAL_SECONDS[interval] * 1000;
-}
-function assertArguments(symbol, startDate, endDate, interval) {
-    if (typeof symbol !== "string" || symbol.trim().length === 0) {
-        throw new TypeError("loadYahooFinanceData() symbol must be a non-empty string.");
-    }
-    if (!(startDate instanceof Date) || !(endDate instanceof Date) ||
-        !Number.isFinite(startDate.getTime()) || !Number.isFinite(endDate.getTime())) {
-        throw new RangeError("loadYahooFinanceData() startDate and endDate must be valid dates.");
-    }
-    if (endDate.getTime() < startDate.getTime()) {
-        throw new RangeError("loadYahooFinanceData() endDate must be equal to or later than startDate.");
-    }
-    if (interval !== "1d" && interval !== "1h" && interval !== "1m") {
-        throw new Error('loadYahooFinanceData() interval must be "1d", "1h", or "1m".');
-    }
-}

package/esm/methods/log.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function log(simpleTable: SimpleTable, options?: "all" | number | {
-    count?: number | "all";
-    types?: boolean;
-    conditions?: string;
-}): Promise<void>;
-//# sourceMappingURL=log.d.ts.map

package/esm/methods/log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/methods/log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,wBAA8B,GAAG,CAC/B,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,KAAK,GAAG,MAAM,GAAG;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,iBAyEP"}

package/esm/methods/log.js

@@ -1,60 +0,0 @@
-import logData from "../helpers/logData.js";
-import getData from "./getData.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import formatNumber from "../helpers/formatNumber.js";
-export default async function log(simpleTable, options = {}) {
-    if (simpleTable.connection === undefined) {
-        await simpleTable.sdb.start();
-        simpleTable.db = simpleTable.sdb.db;
-        simpleTable.connection = simpleTable.sdb.connection;
-    }
-    if (simpleTable.connection === undefined) {
-        throw new Error("simpleTable.connection is undefined");
-    }
-    let count;
-    if (typeof options === "number") {
-        count = options;
-    }
-    else if (options === "all") {
-        count = await simpleTable.getRowCount();
-    }
-    else if (typeof options === "object") {
-        if (options.count === "all") {
-            count = await simpleTable.getRowCount();
-        }
-        else if (typeof options.count === "number") {
-            count = options.count;
-        }
-        else {
-            count = simpleTable.rowsToLog;
-        }
-    }
-    else {
-        count = simpleTable.rowsToLog;
-    }
-    const types = typeof options === "object"
-        ? options.types ?? simpleTable.typesToLog
-        : simpleTable.typesToLog;
-    const conditions = typeof options === "object"
-        ? options.conditions ?? undefined
-        : undefined;
-    if (simpleTable.connection === undefined ||
-        !(await simpleTable.sdb.hasTable(simpleTable.name))) {
-        console.log(`\nTable ${simpleTable.name}: no data`);
-    }
-    else {
-        console.log(`\nTable ${simpleTable.name}:`);
-        conditions && console.log(`Conditions: ${conditions}`);
-        const data = await getData(simpleTable, { limit: count, conditions }, "log()");
-        logData(types ? await simpleTable.getTypes() : null, data, simpleTable.charsToLog);
-        const rowCount = conditions
-            ? parseInt((await simpleTable.sdb.customQuery(`select count(*) as count from ${quoteIdentifier(simpleTable.name)} where ${conditions}`, { returnData: true }))[0].count)
-            : await simpleTable.getRowCount();
-        const displayedRows = data.length;
-        const showing = displayedRows < rowCount
-            ? ` / showing ${formatNumber(displayedRows)} rows`
-            : "";
-        console.log(`${formatNumber(rowCount)} rows in total${showing}`);
-    }
-    return;
-}

package/esm/methods/logBottom.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function logBottom(simpleTable: SimpleTable, count?: number, options?: {
-    originalOrder?: boolean;
-}): Promise<void>;
-//# sourceMappingURL=logBottom.d.ts.map

package/esm/methods/logBottom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logBottom.d.ts","sourceRoot":"","sources":["../../src/methods/logBottom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,iBAW1C"}

package/esm/methods/logBottom.js

@@ -1,9 +0,0 @@
-import logData from "../helpers/logData.js";
-import getBottom from "./getBottom.js";
-export default async function logBottom(simpleTable, count, options = {}) {
-    const rows = count ?? simpleTable.rowsToLog;
-    console.log(`\nTable ${simpleTable.name} (${rows} bottom rows):`);
-    const data = await getBottom(simpleTable, rows, options, "logBottom()");
-    logData(null, data, simpleTable.charsToLog);
-    return;
-}

package/esm/methods/longer.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function longer(simpleTable: SimpleTable, columns: string[], namesTo: string, valuesTo: string): void;
-//# sourceMappingURL=longer.d.ts.map

package/esm/methods/longer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"longer.d.ts","sourceRoot":"","sources":["../../src/methods/longer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,QAuBjB"}

package/esm/methods/longer.js

@@ -1,23 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-export default function longer(simpleTable, columns, namesTo, valuesTo) {
-    columns = [...columns];
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "longer()",
-        parameters: { columns, namesTo, valuesTo },
-        needsSchema: true,
-        buildSelect: (input, schema) => {
-            // The pivoted columns are consumed by UNPIVOT and don't appear in the
-            // output, so namesTo/valuesTo may reuse one of those names.
-            assertNewColumns(schema, [namesTo, valuesTo], "longer()", columns);
-            return `SELECT * FROM (
-            FROM ${input} UNPIVOT INCLUDE NULLS (
-            ${quoteIdentifier(valuesTo)}
-            for ${quoteIdentifier(namesTo)} in (${columns.map((d) => `${quoteIdentifier(d)}`).join(", ")})
-            )
-        )`;
-        },
-    });
-}

package/esm/methods/lower.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function lower(simpleTable: SimpleTable, columns: string | string[]): void;
-//# sourceMappingURL=lower.d.ts.map

package/esm/methods/lower.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../../src/methods/lower.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,QAc3B"}

package/esm/methods/lower.js

@@ -1,14 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import stringToArray from "../helpers/stringToArray.js";
-import queueOp from "../helpers/queueOp.js";
-export default function lower(simpleTable, columns) {
-    const cols = stringToArray(columns);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "lower()",
-        parameters: { columns },
-        needsSchema: false,
-        buildSelect: (input) => `SELECT * REPLACE (${cols.map((c) => `LOWER(${quoteIdentifier(c)}) AS ${quoteIdentifier(c)}`)
-            .join(", ")}) FROM ${input}`,
-    });
-}

package/esm/methods/neighbors.d.ts

@@ -1,9 +0,0 @@
-import { type GraphId } from "../helpers/prepareGraphStarts.js";
-import type SimpleTable from "../class/SimpleTable.js";
-type NeighborsOptions = {
-    direction?: "outgoing" | "incoming" | "both";
-    outputTable?: string | boolean;
-};
-export default function neighbors(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, startNodes: GraphId | GraphId[], options?: NeighborsOptions): SimpleTable;
-export {};
-//# sourceMappingURL=neighbors.d.ts.map

package/esm/methods/neighbors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"neighbors.d.ts","sourceRoot":"","sources":["../../src/methods/neighbors.ts"],"names":[],"mappings":"AAAA,OAA2B,EACzB,KAAK,OAAO,EAEb,MAAM,kCAAkC,CAAC;AAO1C,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,KAAK,gBAAgB,GAAG;IACtB,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,WAAW,CAuEb"}

package/esm/methods/neighbors.js

@@ -1,81 +0,0 @@
-import prepareGraphStarts from "../helpers/prepareGraphStarts.js";
-import prepareGraphTraversal, { validateGraphStarts, } from "../helpers/prepareGraphTraversal.js";
-import queueGraphResult from "../helpers/queueGraphResult.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-export default function neighbors(simpleTable, sourceColumn, targetColumn, startNodes, options = {}) {
-    if (typeof sourceColumn !== "string") {
-        throw new TypeError("neighbors() sourceColumn must be a string.");
-    }
-    if (typeof targetColumn !== "string") {
-        throw new TypeError("neighbors() targetColumn must be a string.");
-    }
-    if (options === null || typeof options !== "object" || Array.isArray(options)) {
-        throw new TypeError("neighbors() options must be an object.");
-    }
-    if (options.direction !== undefined &&
-        !["outgoing", "incoming", "both"].includes(options.direction)) {
-        throw new TypeError('neighbors() options.direction must be "outgoing", "incoming", or "both".');
-    }
-    if (options.outputTable !== undefined &&
-        typeof options.outputTable !== "string" &&
-        typeof options.outputTable !== "boolean") {
-        throw new TypeError("neighbors() options.outputTable must be a string or boolean.");
-    }
-    const preparedStarts = prepareGraphStarts(startNodes, "neighbors()", "startNodes");
-    options = structuredClone(options);
-    const direction = options.direction ?? "outgoing";
-    const parameters = {
-        sourceColumn,
-        targetColumn,
-        startNodes: structuredClone(startNodes),
-        options,
-    };
-    return queueGraphResult(simpleTable, {
-        method: "neighbors()",
-        parameters,
-        outputTable: options.outputTable,
-        values: (schema) => {
-            validateStarts(schema, sourceColumn, targetColumn, preparedStarts);
-            return preparedStarts.values;
-        },
-        buildSelect: (input, schema) => neighborsSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction),
-        outputSchema: (schema) => {
-            const endpoints = validateStarts(schema, sourceColumn, targetColumn, preparedStarts);
-            return { start: endpoints.idType, node: endpoints.idType };
-        },
-    });
-}
-function validateStarts(schema, source, target, starts) {
-    return validateGraphStarts(schema, source, target, starts, "neighbors()", "startNodes");
-}
-function neighborsSelect(input, schema, source, target, starts, direction) {
-    const prepared = prepareGraphTraversal(input, schema, source, target, starts, "neighbors()", "startNodes");
-    const relations = prepared.relationNames([
-        "graph_starts",
-        "graph_edges",
-        "neighbor_matches",
-    ]);
-    const startsRelation = relations.graph_starts;
-    const edgesRelation = relations.graph_edges;
-    const matchesRelation = relations.neighbor_matches;
-    return `WITH ${startsRelation}(${quoteIdentifier("start")}) AS (
-      VALUES ${prepared.startValues}
-    ), ${edgesRelation} AS (
-      ${prepared.edges(direction)}
-    ), ${matchesRelation} AS (
-      SELECT ${quoteIdentifier("starts")}.${quoteIdentifier("start")},
-        ${quoteIdentifier("edges")}.${quoteIdentifier("__to")} AS ${quoteIdentifier("node")},
-        ${quoteIdentifier("edges")}.${quoteIdentifier("__from_key")} AS ${quoteIdentifier("__start_key")},
-        ${quoteIdentifier("edges")}.${quoteIdentifier("__to_key")} AS ${quoteIdentifier("__node_key")}
-      FROM ${edgesRelation} AS ${quoteIdentifier("edges")}
-      INNER JOIN ${startsRelation} AS ${quoteIdentifier("starts")}
-        ON ${quoteIdentifier("edges")}.${quoteIdentifier("__from_key")} =
-          ${prepared.key(`${quoteIdentifier("starts")}.${quoteIdentifier("start")}`)}
-    )
-    SELECT ${quoteIdentifier("start")}, ${quoteIdentifier("node")}
-    FROM (
-      SELECT DISTINCT ${quoteIdentifier("start")}, ${quoteIdentifier("node")}, ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")}
-      FROM ${matchesRelation}
-    ) AS ${quoteIdentifier("distinct_neighbors")}
-    ORDER BY ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")}`;
-}

package/esm/methods/nest.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function nest(simpleTable: SimpleTable, column: string, separator: string, by: string | string[]): void;
-//# sourceMappingURL=nest.d.ts.map

package/esm/methods/nest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nest.d.ts","sourceRoot":"","sources":["../../src/methods/nest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,QAyBtB"}

package/esm/methods/nest.js

@@ -1,23 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function nest(simpleTable, column, separator, by) {
-    by = Array.isArray(by) ? [...by] : by;
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "nest()",
-        parameters: { column, separator, by },
-        values: [separator],
-        needsSchema: false,
-        buildSelect: (input) => {
-            const cats = stringToArray(by);
-            const groupBy = cats.map((d) => `${quoteIdentifier(d)}`).join(", ");
-            const selectColumns = `${groupBy}, `;
-            const orderBy = `\nORDER BY ${cats.map((d) => `${quoteIdentifier(d)} ASC`).join(", ")}`;
-            return `SELECT
-  ${selectColumns}STRING_AGG(${quoteIdentifier(column)}, ?) AS ${quoteIdentifier(column)}
-FROM ${input}
-GROUP BY ${groupBy}${orderBy}`;
-        },
-    });
-}

package/esm/methods/normalize.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function normalize(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
-    by?: string | string[];
-    decimals?: number;
-    range?: [number, number];
-}): void;
-//# sourceMappingURL=normalize.d.ts.map

package/esm/methods/normalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/methods/normalize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrB,QAkDP"}

package/esm/methods/normalize.js

@@ -1,41 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function normalize(simpleTable, column, newColumn, options = {}) {
-    if (options.range !== undefined &&
-        (!Array.isArray(options.range) ||
-            options.range.length !== 2 ||
-            !Number.isFinite(options.range[0]) ||
-            !Number.isFinite(options.range[1]) ||
-            options.range[0] >= options.range[1])) {
-        throw new Error("normalize() options.range must contain two finite numbers in ascending order.");
-    }
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "normalize()",
-        parameters: { column, newColumn, options },
-        needsSchema: true,
-        buildSelect: (input, schema) => {
-            assertNewColumns(schema, [newColumn], "normalize()");
-            const by = options.by ? stringToArray(options.by) : [];
-            const partition = by.length > 0
-                ? `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")}`
-                : "";
-            const normalizedQuery = `(${quoteIdentifier(column)} - MIN(${quoteIdentifier(column)}) OVER(${partition}))
-    /
-    (MAX(${quoteIdentifier(column)}) OVER(${partition}) - MIN(${quoteIdentifier(column)}) OVER(${partition}))`;
-            const [rangeMin, rangeMax] = options.range ?? [0, 1];
-            const scaledQuery = options.range === undefined
-                ? normalizedQuery
-                : `${rangeMin} + (${normalizedQuery}) * ${rangeMax - rangeMin}`;
-            return `SELECT *, (
-        ${typeof options.decimals === "number"
-                ? `ROUND(${scaledQuery}, ${options.decimals})`
-                : scaledQuery}
-        ) AS ${quoteIdentifier(newColumn)},
-    FROM ${input}`;
-        },
-    });
-}

package/esm/methods/normalizeString.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function normalizeString(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
-    stripPunctuation?: boolean;
-}): void;
-//# sourceMappingURL=normalizeString.d.ts.map

package/esm/methods/normalizeString.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeString.d.ts","sourceRoot":"","sources":["../../src/methods/normalizeString.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,IAAI,CA2BN"}

package/esm/methods/normalizeString.js

@@ -1,23 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-export default function normalizeString(simpleTable, column, newColumn, options = {}) {
-    const { stripPunctuation = true } = options;
-    const accentRemoved = `strip_accents(${quoteIdentifier(column)})`;
-    const lowercased = `lower(${accentRemoved})`;
-    const punctuationRemoved = stripPunctuation
-        ? `regexp_replace(${lowercased}, '[[:punct:]]', '', 'g')`
-        : lowercased;
-    const normalizedClause = `trim(regexp_replace(${punctuationRemoved}, '\\s+', ' ', 'g'))`;
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "normalizeString()",
-        parameters: { column, newColumn, stripPunctuation },
-        needsSchema: false,
-        buildSelect: (input) => `SELECT *,
-      CASE
-        WHEN ${quoteIdentifier(column)} IS NULL THEN NULL
-        ELSE ${normalizedClause}
-      END AS ${quoteIdentifier(newColumn)}
-    FROM ${input}`,
-    });
-}

package/esm/methods/normalizeVector.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-type Options = NonNullable<Parameters<SimpleTable["normalizeVector"]>[2]>;
-export default function normalizeVector(table: SimpleTable, column: string, newColumn: string, options?: Options): void;
-export {};
-//# sourceMappingURL=normalizeVector.d.ts.map

package/esm/methods/normalizeVector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeVector.d.ts","sourceRoot":"","sources":["../../src/methods/normalizeVector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,KAAK,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,OAAY,GACpB,IAAI,CAiBN"}

package/esm/methods/normalizeVector.js

@@ -1,132 +0,0 @@
-import foldIdentifier from "../helpers/foldIdentifier.js";
-import prepareNumericFeatures from "../helpers/prepareNumericFeatures.js";
-import publishPreparedColumns from "../helpers/publishPreparedColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-export default function normalizeVector(table, column, newColumn, options = {}) {
-    if (options.normalization !== undefined &&
-        options.normalization !== "dimensionMinMax" &&
-        options.normalization !== "rowL2") {
-        throw new Error('normalizeVector() options.normalization must be "dimensionMinMax" or "rowL2".');
-    }
-    const settings = structuredClone(options);
-    queueOp(table, {
-        kind: "barrier",
-        method: "normalizeVector()",
-        parameters: { column, newColumn, options: settings },
-        execute: () => execute(table, column, newColumn, settings),
-    });
-}
-async function execute(table, column, newColumn, options) {
-    const normalization = options.normalization ?? "dimensionMinMax";
-    const overwrite = foldIdentifier(column) === foldIdentifier(newColumn);
-    if (!overwrite) {
-        const sourceColumns = Object.keys(await table.getTypes());
-        if (sourceColumns.some((name) => foldIdentifier(name) === foldIdentifier(newColumn))) {
-            throw new Error(`normalizeVector() cannot create ${quoteIdentifier(newColumn)} because that column already exists. Remove it first or choose a different name.`);
-        }
-    }
-    const prepared = await prepareNumericFeatures(table, { kind: "vector", column }, { method: "normalizeVector()" });
-    const connection = table.connection;
-    const q = quoteIdentifier;
-    const suffix = crypto.randomUUID().replaceAll("-", "");
-    const statsName = `__sda_normalize_vector_${suffix}_stats`;
-    const resultName = `__sda_normalize_vector_${suffix}_result`;
-    const dimension = q(`__sda_dimension_${suffix}`);
-    const minimum = q(`__sda_min_${suffix}`);
-    const maximum = q(`__sda_max_${suffix}`);
-    const normalized = `__sda_normalized_${suffix}`;
-    try {
-        if (prepared.rowCount === 0) {
-            throw new Error("normalizeVector() requires at least one row; the dataset is empty.");
-        }
-        const sourceColumn = prepared.sourceColumns.find((name) => foldIdentifier(name) === foldIdentifier(column));
-        if (normalization === "rowL2") {
-            // Scale before squaring so extreme finite magnitudes do not overflow
-            // or underflow the norm. A zero vector stays zero.
-            await connection.run(`CREATE TEMP TABLE ${q(resultName)} AS
-         WITH magnitudes AS (
-           SELECT ${q(prepared.rowIdColumn)}, ${q(prepared.vectorColumn)} AS vec,
-             list_max(list_transform(${q(prepared.vectorColumn)}, value -> abs(value))) AS magnitude
-           FROM ${q(prepared.relation)}
-         ), scaled AS (
-           SELECT *, list_transform(vec, value -> value / nullif(magnitude, 0)) AS unit_scale
-           FROM magnitudes
-         ), norms AS (
-           SELECT *, sqrt(list_sum(list_transform(unit_scale, value -> value * value))) AS norm
-           FROM scaled
-         )
-         SELECT ${q(prepared.rowIdColumn)},
-           (CASE WHEN magnitude = 0 THEN vec::DOUBLE[]
-             ELSE list_transform(unit_scale, value -> value / norm)
-           END)::DOUBLE[${prepared.dimensions}] AS ${q(normalized)}
-         FROM norms`);
-        }
-        else {
-            await connection.run(`CREATE TEMP TABLE ${q(statsName)} AS
-         SELECT ordinal::BIGINT AS ${dimension}, min(value)::DOUBLE AS ${minimum},
-           max(value)::DOUBLE AS ${maximum}
-         FROM ${q(prepared.relation)} p,
-           UNNEST(p.${q(prepared.vectorColumn)}::DOUBLE[]) WITH ORDINALITY AS values(value, ordinal)
-         GROUP BY ordinal`);
-            const invalidStats = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${q(statsName)}
-           WHERE NOT isfinite(${minimum}) OR NOT isfinite(${maximum})`)).getRowsJS()[0][0]);
-            if (invalidStats > 0) {
-                throw new Error(`normalizeVector() found ${invalidStats} dimension${invalidStats === 1 ? "" : "s"} with non-finite aggregate values after conversion to DOUBLE.`);
-            }
-            const constantDimensions = (await connection.runAndReadAll(`SELECT ${dimension} FROM ${q(statsName)}
-         WHERE ${minimum} = ${maximum} ORDER BY ${dimension}`)).getRowsJS().map((row) => Number(row[0]));
-            if (constantDimensions.length > 0) {
-                throw new Error(`normalizeVector() cannot scale constant dimension${constantDimensions.length === 1 ? "" : "s"} ${constantDimensions.join(", ")} in column ${q(sourceColumn)} because the range is zero. Remove ${constantDimensions.length === 1
-                    ? "that dimension"
-                    : "those dimensions"} before normalizing. Conversion to DOUBLE can also collapse distinct large integers or decimals at its precision limit.`);
-            }
-            const value = `p.${q(prepared.vectorColumn)}[s.${dimension}]`;
-            const min = `s.${minimum}`;
-            const max = `s.${maximum}`;
-            // Dividing both sides by the larger magnitude when a range crosses zero
-            // avoids overflowing max - min for extreme finite DOUBLE values.
-            const scaled = `CASE
-        WHEN ${min} < 0 AND ${max} > 0 AND -${min} >= ${max}
-          THEN ((${value} / -${min}) + 1.0) / ((${max} / -${min}) + 1.0)
-        WHEN ${min} < 0 AND ${max} > 0
-          THEN ((${value} / ${max}) + (-${min} / ${max})) /
-            (1.0 + (-${min} / ${max}))
-        ELSE (${value} - ${min}) / (${max} - ${min})
-      END`;
-            await connection.run(`CREATE TEMP TABLE ${q(resultName)} AS
-         SELECT p.${q(prepared.rowIdColumn)},
-           list(${scaled} ORDER BY s.${dimension})::DOUBLE[${prepared.dimensions}]
-             AS ${q(normalized)}
-         FROM ${q(prepared.relation)} p CROSS JOIN ${q(statsName)} s
-         GROUP BY p.${q(prepared.rowIdColumn)}`);
-        }
-        const invalidResults = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${q(resultName)}
-         WHERE ${q(normalized)} IS NULL
-           OR list_count(${q(normalized)}) != ${prepared.dimensions}
-           OR NOT list_bool_and(list_transform(${q(normalized)}, value -> isfinite(value)))
-           OR list_min(${q(normalized)}) < ${normalization === "rowL2" ? -1 : 0}
-           OR list_max(${q(normalized)}) > 1`)).getRowsJS()[0][0]);
-        if (invalidResults > 0) {
-            throw new Error(`normalizeVector() produced non-finite or out-of-range values for ${invalidResults} row${invalidResults === 1 ? "" : "s"}. Rescale the source values before normalizing.`);
-        }
-        await publishPreparedColumns(table, prepared, {
-            method: "normalizeVector()",
-            parameters: { column, newColumn, options },
-            result: {
-                relation: resultName,
-                rowIdColumn: prepared.rowIdColumn,
-            },
-            outputs: [{
-                    name: overwrite ? sourceColumn : newColumn,
-                    expression: `r.${q(normalized)}`,
-                    replace: overwrite ? sourceColumn : undefined,
-                }],
-        });
-    }
-    finally {
-        await connection.run(`DROP TABLE IF EXISTS ${q(resultName)}`);
-        await connection.run(`DROP TABLE IF EXISTS ${q(statsName)}`);
-        await prepared.cleanup();
-    }
-}