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

package/esm/helpers/computeCovariance.js

@@ -1,99 +0,0 @@
-import quoteIdentifier from "./quoteIdentifier.js";
-import { factorCovariance } from "./factorCovariance.js";
-export default async function computeCovariance(connection, input) {
-    const { observations, dimensions } = input;
-    if (!Number.isSafeInteger(dimensions) || dimensions < 1) {
-        throw new Error("Covariance requires at least one feature dimension.");
-    }
-    if (!Number.isSafeInteger(observations) || observations <= dimensions) {
-        throw new Error(`Covariance requires more observations than features (n > d), but received n=${observations} and d=${dimensions}. More observations are necessary, though constant or linearly dependent features can still make covariance singular.`);
-    }
-    const relation = quoteIdentifier(input.relation);
-    const rowId = quoteIdentifier(input.rowIdColumn);
-    const vector = quoteIdentifier(input.vectorColumn);
-    const expanded = `SELECT r.${rowId} AS observation,
-      f.feature::INTEGER AS feature,
-      array_extract(r.${vector}, f.feature)::DOUBLE AS value
-    FROM ${relation} r CROSS JOIN range(1, ${dimensions + 1}) f(feature)`;
-    const offsets = `SELECT observation, feature, value,
-      first_value(value) OVER (PARTITION BY feature ORDER BY observation
-        ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS origin
-    FROM (${expanded})`;
-    const meanRows = (await connection.runAndReadAll(`SELECT feature - 1 AS feature, first(origin) AS origin,
-      avg(value - origin) AS mean_offset, max(abs(value - origin)) AS magnitude FROM (${offsets})
-      GROUP BY feature ORDER BY feature`)).getRowsJS();
-    if (meanRows.length !== dimensions) {
-        throw new Error("Covariance aggregation returned an incomplete centroid.");
-    }
-    const magnitudes = new Float64Array(dimensions);
-    const means = new Float64Array(dimensions);
-    const origins = new Float64Array(dimensions);
-    const meanOffsets = new Float64Array(dimensions);
-    for (const row of meanRows) {
-        const feature = Number(row[0]);
-        const origin = Number(row[1]);
-        const meanOffset = Number(row[2]);
-        if (!Number.isSafeInteger(feature) || !Number.isFinite(origin) ||
-            !Number.isFinite(meanOffset)) {
-            throw new Error("Covariance is numerically unstable because centroid aggregation produced a non-finite result. Rescale features or remove dimensions whose range cannot be represented as DOUBLE.");
-        }
-        const magnitude = Number(row[3]);
-        if (!Number.isFinite(magnitude) || magnitude <= 0) {
-            throw new Error(`Covariance is singular or numerically unstable (feature ${feature + 1} has constant values or an unrepresentable range). Constant columns, linearly dependent features, or too few observations are common causes. Remove redundant features or provide more observations.`);
-        }
-        magnitudes[feature] = magnitude;
-        origins[feature] = origin;
-        meanOffsets[feature] = meanOffset;
-        means[feature] = origin + meanOffset;
-    }
-    const covariance = new Float64Array(dimensions * dimensions);
-    // covar_samp divides centered cross-products by n - 1. Subtracting a native
-    // per-feature anchor first avoids cancellation in E[x*y] - E[x]E[y] and
-    // retains small deviations when a feature has a large common offset.
-    // Divide by each feature's observed magnitude before accumulating products.
-    // Otherwise the n-1 cross-product sum can overflow even when the final sample
-    // covariance is finite (e.g. [0, 1e154, 2e154], whose variance is 1e308).
-    const result = await connection.stream(`WITH features AS MATERIALIZED (
-        SELECT observation, feature, (value - origin) /
-          array_extract([${magnitudes.join(",")}]::DOUBLE[${dimensions}], feature) AS value
-        FROM (${offsets})
-      )
-      SELECT a.feature - 1 AS row, b.feature - 1 AS column,
-        covar_samp(a.value, b.value) AS covariance
-      FROM features a JOIN features b
-        ON a.observation = b.observation AND a.feature <= b.feature
-      GROUP BY a.feature, b.feature`);
-    let values = 0;
-    while (true) {
-        const chunk = await result.fetchChunk();
-        if (!chunk || chunk.rowCount === 0)
-            break;
-        const rows = new Int32Array(chunk.rowCount);
-        const columns = new Int32Array(chunk.rowCount);
-        const entries = new Float64Array(chunk.rowCount);
-        chunk.visitColumnValues(0, (value, row) => rows[row] = Number(value));
-        chunk.visitColumnValues(1, (value, row) => columns[row] = Number(value));
-        chunk.visitColumnValues(2, (value, row) => entries[row] = Number(value));
-        for (let i = 0; i < chunk.rowCount; i++) {
-            const row = rows[i];
-            const column = columns[i];
-            // Restore units using the larger magnitude first to avoid prematurely
-            // underflowing a finite cross-covariance between very different units.
-            const value = entries[i] * Math.max(magnitudes[row], magnitudes[column]) *
-                Math.min(magnitudes[row], magnitudes[column]);
-            covariance[row * dimensions + column] = value;
-            covariance[column * dimensions + row] = value;
-            values++;
-        }
-    }
-    if (values !== dimensions * (dimensions + 1) / 2) {
-        throw new Error("Covariance aggregation returned an incomplete matrix.");
-    }
-    return {
-        ...factorCovariance(covariance, dimensions),
-        means,
-        origins,
-        meanOffsets,
-        observations,
-    };
-}

package/esm/helpers/computeMahalanobisDistances.d.ts

@@ -1,14 +0,0 @@
-import { type DuckDBConnection } from "@duckdb/node-api";
-import type { CovarianceModel } from "./computeCovariance.js";
-/** Evaluates bulk distances in DuckDB; the caller owns the returned scratch table. */
-export default function computeMahalanobisDistances(connection: DuckDBConnection, input: {
-    relation: string;
-    rowIdColumn: string;
-    vectorColumn: string;
-}, model: CovarianceModel, referencePoint?: number[]): Promise<{
-    relation: string;
-    rowIdColumn: string;
-    distanceColumn: string;
-    cleanup: () => Promise<void>;
-}>;
-//# sourceMappingURL=computeMahalanobisDistances.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"computeMahalanobisDistances.d.ts","sourceRoot":"","sources":["../../src/helpers/computeMahalanobisDistances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAI9D,sFAAsF;AACtF,wBAA8B,2BAA2B,CACvD,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE;IACL,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,EACD,KAAK,EAAE,eAAe,EACtB,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,OAAO,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC,CAkGD"}

package/esm/helpers/computeMahalanobisDistances.js

@@ -1,87 +0,0 @@
-import { ARRAY, DOUBLE } from "@duckdb/node-api";
-import { covarianceWhitening } from "./factorCovariance.js";
-import quoteIdentifier from "./quoteIdentifier.js";
-/** Evaluates bulk distances in DuckDB; the caller owns the returned scratch table. */
-export default async function computeMahalanobisDistances(connection, input, model, referencePoint) {
-    const { dimensions, means, origins, meanOffsets } = model;
-    if ([means, origins, meanOffsets].some((values) => values.length !== dimensions)) {
-        throw new Error("The covariance centroid has the wrong dimensions.");
-    }
-    const vectorLiteral = (values) => {
-        if (values.some((value) => !Number.isFinite(value))) {
-            throw new Error("Mahalanobis centering requires finite coefficients.");
-        }
-        return `[${values.join(",")}]::DOUBLE[${dimensions}]`;
-    };
-    const originSql = vectorLiteral(origins);
-    const offsetSql = vectorLiteral(meanOffsets);
-    if (referencePoint !== undefined &&
-        (referencePoint.length !== dimensions ||
-            referencePoint.some((value) => !Number.isFinite(value)))) {
-        throw new Error("Mahalanobis reference point must contain one finite number per dimension.");
-    }
-    // Direct subtraction retains exact matches and tiny reference offsets that
-    // would be lost by subtracting the centroid from both points separately.
-    const centeredValue = referencePoint === undefined
-        ? `(value - array_extract(${originSql}, dimension)) - array_extract(${offsetSql}, dimension)`
-        : `value - array_extract(${vectorLiteral(Float64Array.from(referencePoint))}, dimension)`;
-    const whitening = covarianceWhitening(model);
-    const suffix = crypto.randomUUID().replaceAll("-", "");
-    const relation = `__sda_mahalanobis_distances_${suffix}`;
-    const weights = `__sda_mahalanobis_weights_${suffix}`;
-    const rowIdColumn = "row_id";
-    const distanceColumn = "distance";
-    const cleanup = async () => {
-        await connection.run(`DROP TABLE IF EXISTS ${quoteIdentifier(relation)}`);
-    };
-    try {
-        await connection.run(`CREATE TEMP TABLE ${quoteIdentifier(weights)}
-      (weight DOUBLE[${dimensions}])`);
-        const appender = await connection.createAppender(weights);
-        try {
-            // Only O(d²) summary state crosses this boundary, one O(d) row at a time.
-            // Binding a native table avoids parsing a matrix-sized SQL literal and
-            // repeatedly evaluating it inside a per-observation lambda.
-            for (let row = 0; row < dimensions; row++) {
-                appender.appendArray(Array.from(whitening.subarray(row * dimensions, (row + 1) * dimensions)), ARRAY(DOUBLE, dimensions));
-                appender.endRow();
-            }
-            appender.flushSync();
-        }
-        finally {
-            appender.closeSync();
-        }
-        // Center once per observation. The cross product is consumed by a grouped
-        // aggregate: O(n d²) arithmetic, O(n d) centered storage, O(d²) coefficients,
-        // and O(n) aggregate/output state. Source vectors never enter JavaScript.
-        await connection.run(`CREATE TEMP TABLE ${quoteIdentifier(relation)} AS
-      WITH centered AS MATERIALIZED (
-        SELECT ${quoteIdentifier(input.rowIdColumn)} AS row_id,
-          list_transform(${quoteIdentifier(input.vectorColumn)},
-            (value, dimension) -> ${centeredValue})::DOUBLE[${dimensions}] AS vector
-        FROM ${quoteIdentifier(input.relation)}
-      ), components AS MATERIALIZED (
-        SELECT row_id, abs(array_inner_product(weight, vector)) AS component
-        FROM centered CROSS JOIN ${quoteIdentifier(weights)}
-      ), magnitudes AS (
-        SELECT row_id, max(component) AS magnitude FROM components GROUP BY row_id
-      )
-      SELECT row_id, CASE WHEN magnitude = 0 THEN 0::DOUBLE
-        ELSE magnitude * sqrt(sum(pow(component / magnitude, 2))) END AS distance
-      FROM components JOIN magnitudes USING (row_id)
-      GROUP BY row_id, magnitude`);
-        const invalid = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${quoteIdentifier(relation)}
-        WHERE distance IS NULL OR NOT isfinite(distance)`)).getRowsJS()[0][0]);
-        if (invalid > 0) {
-            throw new Error(`Mahalanobis distance produced ${invalid} non-finite results. Rescale features or remove numerically unstable dimensions.`);
-        }
-        return { relation, rowIdColumn, distanceColumn, cleanup };
-    }
-    catch (error) {
-        await cleanup();
-        throw error;
-    }
-    finally {
-        await connection.run(`DROP TABLE IF EXISTS ${quoteIdentifier(weights)}`);
-    }
-}

package/esm/helpers/createDirectory.d.ts

@@ -1,16 +0,0 @@
-/**
- * Creates missing directories in an output path, including parent directories.
- * Non-hidden path segments containing a dot are treated as filenames and omitted.
- *
- * @example
- * ```ts
- * import { createDirectory } from "@nshiab/simple-data-analysis-core/helpers";
- * createDirectory("output/tables/results.csv"); // Creates output/tables.
- * ```
- *
- * @param path - An output file path or a directory path without dotted segments.
- *
- * @returns Nothing. Existing directories are left unchanged.
- */
-export default function createDirectory(path: string): void;
-//# sourceMappingURL=createDirectory.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createDirectory.d.ts","sourceRoot":"","sources":["../../src/helpers/createDirectory.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAS1D"}

package/esm/helpers/createDirectory.js

@@ -1,24 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-/**
- * Creates missing directories in an output path, including parent directories.
- * Non-hidden path segments containing a dot are treated as filenames and omitted.
- *
- * @example
- * ```ts
- * import { createDirectory } from "@nshiab/simple-data-analysis-core/helpers";
- * createDirectory("output/tables/results.csv"); // Creates output/tables.
- * ```
- *
- * @param path - An output file path or a directory path without dotted segments.
- *
- * @returns Nothing. Existing directories are left unchanged.
- */
-export default function createDirectory(path) {
-    path = path
-        .split("/")
-        .filter((d) => (d.startsWith(".") ? true : !d.includes(".")))
-        .join("/");
-    if (path !== "" && !existsSync(path)) {
-        mkdirSync(path, { recursive: true });
-    }
-}

package/esm/helpers/csvFormat.d.ts

@@ -1,3 +0,0 @@
-declare var csvFormat_default: any;
-export { csvFormat_default as default };
-//# sourceMappingURL=csvFormat.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"csvFormat.d.ts","sourceRoot":"","sources":["../../src/helpers/csvFormat.ts"],"names":[],"mappings":"AAuJA,QAAA,IAAI,iBAAiB,EAAE,GAAe,CAAC;AACvC,OAAO,EACL,iBAAiB,IAAI,OAAO,EAC7B,CAAC"}

package/esm/helpers/csvFormat.js

@@ -1,165 +0,0 @@
-// @ts-nocheck
-// deno-lint-ignore-file
-// Created by bundling csvFormat from d3-dsv.
-// Original source: https://github.com/d3/d3-dsv
-// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/dsv.js
-var EOL = {};
-var EOF = {};
-var QUOTE = 34;
-var NEWLINE = 10;
-var RETURN = 13;
-function objectConverter(columns) {
-    return new Function("d", "return {" + columns.map(function (name, i) {
-        return JSON.stringify(name) + ": d[" + i + '] || ""';
-    }).join(",") + "}");
-}
-function customConverter(columns, f) {
-    var object = objectConverter(columns);
-    return function (row, i) {
-        return f(object(row), i, columns);
-    };
-}
-function inferColumns(rows) {
-    var columnSet = /* @__PURE__ */ Object.create(null), columns = [];
-    rows.forEach(function (row) {
-        for (var column in row) {
-            if (!(column in columnSet)) {
-                columns.push(columnSet[column] = column);
-            }
-        }
-    });
-    return columns;
-}
-function pad(value, width) {
-    var s = value + "", length = s.length;
-    return length < width ? new Array(width - length + 1).join(0) + s : s;
-}
-function formatYear(year) {
-    return year < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4);
-}
-function formatDate(date) {
-    var hours = date.getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds();
-    return isNaN(date) ? "Invalid Date" : formatYear(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "");
-}
-function dsv_default(delimiter) {
-    var reFormat = new RegExp('["' + delimiter + "\n\r]"), DELIMITER = delimiter.charCodeAt(0);
-    function parse(text, f) {
-        var convert, columns, rows = parseRows(text, function (row, i) {
-            if (convert)
-                return convert(row, i - 1);
-            columns = row, convert = f ? customConverter(row, f) : objectConverter(row);
-        });
-        rows.columns = columns || [];
-        return rows;
-    }
-    function parseRows(text, f) {
-        var rows = [], N = text.length, I = 0, n = 0, t, eof = N <= 0, eol = false;
-        if (text.charCodeAt(N - 1) === NEWLINE)
-            --N;
-        if (text.charCodeAt(N - 1) === RETURN)
-            --N;
-        function token() {
-            if (eof)
-                return EOF;
-            if (eol)
-                return eol = false, EOL;
-            var i, j = I, c;
-            if (text.charCodeAt(j) === QUOTE) {
-                while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE)
-                    ;
-                if ((i = I) >= N)
-                    eof = true;
-                else if ((c = text.charCodeAt(I++)) === NEWLINE)
-                    eol = true;
-                else if (c === RETURN) {
-                    eol = true;
-                    if (text.charCodeAt(I) === NEWLINE)
-                        ++I;
-                }
-                return text.slice(j + 1, i - 1).replace(/""/g, '"');
-            }
-            while (I < N) {
-                if ((c = text.charCodeAt(i = I++)) === NEWLINE)
-                    eol = true;
-                else if (c === RETURN) {
-                    eol = true;
-                    if (text.charCodeAt(I) === NEWLINE)
-                        ++I;
-                }
-                else if (c !== DELIMITER)
-                    continue;
-                return text.slice(j, i);
-            }
-            return eof = true, text.slice(j, N);
-        }
-        while ((t = token()) !== EOF) {
-            var row = [];
-            while (t !== EOL && t !== EOF)
-                row.push(t), t = token();
-            if (f && (row = f(row, n++)) == null)
-                continue;
-            rows.push(row);
-        }
-        return rows;
-    }
-    function preformatBody(rows, columns) {
-        return rows.map(function (row) {
-            return columns.map(function (column) {
-                return formatValue(row[column]);
-            }).join(delimiter);
-        });
-    }
-    function format(rows, columns) {
-        if (columns == null)
-            columns = inferColumns(rows);
-        return [
-            columns.map(formatValue).join(delimiter)
-        ].concat(preformatBody(rows, columns)).join("\n");
-    }
-    function formatBody(rows, columns) {
-        if (columns == null)
-            columns = inferColumns(rows);
-        return preformatBody(rows, columns).join("\n");
-    }
-    function formatRows(rows) {
-        return rows.map(formatRow).join("\n");
-    }
-    function formatRow(row) {
-        return row.map(formatValue).join(delimiter);
-    }
-    function formatValue(value) {
-        return value == null ? "" : value instanceof Date ? formatDate(value) : reFormat.test(value += "") ? '"' + value.replace(/"/g, '""') + '"' : value;
-    }
-    return {
-        parse,
-        parseRows,
-        format,
-        formatBody,
-        formatRows,
-        formatRow,
-        formatValue
-    };
-}
-// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/csv.js
-var csv = dsv_default(",");
-var csvParse = csv.parse;
-var csvParseRows = csv.parseRows;
-var csvFormat = csv.format;
-var csvFormatBody = csv.formatBody;
-var csvFormatRows = csv.formatRows;
-var csvFormatRow = csv.formatRow;
-var csvFormatValue = csv.formatValue;
-// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/tsv.js
-var tsv = dsv_default("	");
-var tsvParse = tsv.parse;
-var tsvParseRows = tsv.parseRows;
-var tsvFormat = tsv.format;
-var tsvFormatBody = tsv.formatBody;
-var tsvFormatRows = tsv.formatRows;
-var tsvFormatRow = tsv.formatRow;
-var tsvFormatValue = tsv.formatValue;
-// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/autoType.js
-var fixtz = ( /* @__PURE__ */new Date("2019-01-01T00:00")).getHours() || ( /* @__PURE__ */new Date("2019-07-01T00:00")).getHours();
-// tmp/csvFormat.ts
-var csvFormat_default = csvFormat;
-export { csvFormat_default as default };

package/esm/helpers/dataToArrays.d.ts

@@ -1,53 +0,0 @@
-/**
- * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
- *
- * @example
- * ```ts
- * // Basic usage with a simple dataset
- * const rowData = [
- *   { name: 'Alice', age: 30, city: 'New York' },
- *   { name: 'Bob', age: 25, city: 'London' },
- *   { name: 'Charlie', age: 35, city: 'Paris' }
- * ];
- *
- * const columnarData = dataToArrays(rowData);
- *
- * console.log(columnarData);
- * // Expected output:
- * // {
- * //   name: ['Alice', 'Bob', 'Charlie'],
- * //   age: [30, 25, 35],
- * //   city: ['New York', 'London', 'Paris']
- * // }
- * ```
- *
- * @example
- * ```ts
- * // Preparing data for statistical analysis
- * const measurements = [
- *   { id: 1, temp: 20, humidity: 60 },
- *   { id: 2, temp: 22, humidity: 65 },
- *   { id: 3, temp: 18, humidity: 55 }
- * ];
- *
- * const separatedVariables = dataToArrays(measurements);
- *
- * console.log(separatedVariables);
- * // Expected output:
- * // {
- * //   id: [1, 2, 3],
- * //   temp: [20, 22, 18],
- * //   humidity: [60, 65, 55]
- * // }
- * ```
- *
- * @param data An array of objects. Each object is expected to have the same set of keys.
- *
- * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
- *
- * @category Formatting
- */
-export default function dataToArrays<T extends Record<string, unknown>>(data: T[]): {
-    [K in keyof T]: T[K][];
-};
-//# sourceMappingURL=dataToArrays.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dataToArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/dataToArrays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,IAAI,EAAE,CAAC,EAAE,GACR;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;CAAE,CAU5B"}

package/esm/helpers/dataToArrays.js

@@ -1,57 +0,0 @@
-/**
- * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
- *
- * @example
- * ```ts
- * // Basic usage with a simple dataset
- * const rowData = [
- *   { name: 'Alice', age: 30, city: 'New York' },
- *   { name: 'Bob', age: 25, city: 'London' },
- *   { name: 'Charlie', age: 35, city: 'Paris' }
- * ];
- *
- * const columnarData = dataToArrays(rowData);
- *
- * console.log(columnarData);
- * // Expected output:
- * // {
- * //   name: ['Alice', 'Bob', 'Charlie'],
- * //   age: [30, 25, 35],
- * //   city: ['New York', 'London', 'Paris']
- * // }
- * ```
- *
- * @example
- * ```ts
- * // Preparing data for statistical analysis
- * const measurements = [
- *   { id: 1, temp: 20, humidity: 60 },
- *   { id: 2, temp: 22, humidity: 65 },
- *   { id: 3, temp: 18, humidity: 55 }
- * ];
- *
- * const separatedVariables = dataToArrays(measurements);
- *
- * console.log(separatedVariables);
- * // Expected output:
- * // {
- * //   id: [1, 2, 3],
- * //   temp: [20, 22, 18],
- * //   humidity: [60, 65, 55]
- * // }
- * ```
- *
- * @param data An array of objects. Each object is expected to have the same set of keys.
- *
- * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
- *
- * @category Formatting
- */
-export default function dataToArrays(data) {
-    const newData = {};
-    const keys = Object.keys(data[0]);
-    for (const key of keys) {
-        newData[key] = data.map((d) => d[key]);
-    }
-    return newData;
-}

package/esm/helpers/ensureSpatial.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-/**
- * Loads the spatial extension once per connection, so geospatial operations
- * can fuse as plain SELECT fragments instead of each being multi-statement.
- */
-export default function ensureSpatial(simpleTable: SimpleTable): Promise<void>;
-//# sourceMappingURL=ensureSpatial.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ensureSpatial.d.ts","sourceRoot":"","sources":["../../src/helpers/ensureSpatial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;GAGG;AACH,wBAA8B,aAAa,CACzC,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/esm/helpers/ensureSpatial.js

@@ -1,17 +0,0 @@
-import mergeOptions from "./mergeOptions.js";
-import queryDB from "./queryDB.js";
-/**
- * Loads the spatial extension once per connection, so geospatial operations
- * can fuse as plain SELECT fragments instead of each being multi-statement.
- */
-export default async function ensureSpatial(simpleTable) {
-    if (simpleTable.sdb.spatialLoaded) {
-        return;
-    }
-    await queryDB(simpleTable, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;`, mergeOptions(simpleTable, {
-        table: null,
-        method: null,
-        parameters: null,
-    }));
-    simpleTable.sdb.spatialLoaded = true;
-}

package/esm/helpers/extractTypes.d.ts

@@ -1,6 +0,0 @@
-export default function extractTypes(types: {
-    [key: string]: unknown;
-}[] | null): {
-    [k: string]: string;
-};
-//# sourceMappingURL=extractTypes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"extractTypes.d.ts","sourceRoot":"","sources":["../../src/helpers/extractTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,EAAE,GAAG,IAAI;;EAaX"}

package/esm/helpers/extractTypes.js

@@ -1,6 +0,0 @@
-export default function extractTypes(types) {
-    const rows = (types ?? []);
-    // Define own properties so valid names such as __proto__ do not invoke
-    // Object.prototype setters in Node.js.
-    return Object.fromEntries(rows.filter((row) => row.column_name).map((row) => [row.column_name, row.column_type]));
-}

package/esm/helpers/extractZipEntryToFile.d.ts

@@ -1,3 +0,0 @@
-/** Extracts one entry from a non-ZIP64, single-disk ZIP without buffering it. */
-export default function extractZipEntryToFile(archive: string, wantedName: string, output: string): Promise<void>;
-//# sourceMappingURL=extractZipEntryToFile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"extractZipEntryToFile.d.ts","sourceRoot":"","sources":["../../src/helpers/extractZipEntryToFile.ts"],"names":[],"mappings":"AAgDA,iFAAiF;AACjF,wBAA8B,qBAAqB,CACjD,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAyEf"}