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

package/esm/helpers/writeZip.js

@@ -1,257 +0,0 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _ChecksumTransform_crc32, _FileHandleWritable_fileHandle;
-import { createReadStream } from "node:fs";
-import { open, rm, stat } from "node:fs/promises";
-import { basename } from "node:path";
-import { Transform, Writable, } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import * as zlib from "node:zlib";
-import { constants, createDeflateRaw } from "node:zlib";
-const maximumZip32Value = 0xffff_fffe;
-const maximumZip32Entries = 0xfffe;
-const utf8WithDataDescriptor = 0x0808;
-const crc32Table = createCrc32Table();
-class ChecksumTransform extends Transform {
-    constructor() {
-        super(...arguments);
-        _ChecksumTransform_crc32.set(this, 0);
-        Object.defineProperty(this, "size", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-    }
-    get crc32() {
-        return __classPrivateFieldGet(this, _ChecksumTransform_crc32, "f");
-    }
-    _transform(chunk, _encoding, callback) {
-        __classPrivateFieldSet(this, _ChecksumTransform_crc32, updateCrc32(chunk, __classPrivateFieldGet(this, _ChecksumTransform_crc32, "f")), "f");
-        this.size += chunk.byteLength;
-        callback(null, chunk);
-    }
-}
-_ChecksumTransform_crc32 = new WeakMap();
-class FileHandleWritable extends Writable {
-    constructor(fileHandle, options) {
-        super(options);
-        Object.defineProperty(this, "bytesWritten", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        _FileHandleWritable_fileHandle.set(this, void 0);
-        __classPrivateFieldSet(this, _FileHandleWritable_fileHandle, fileHandle, "f");
-    }
-    _write(chunk, _encoding, callback) {
-        writeAll(__classPrivateFieldGet(this, _FileHandleWritable_fileHandle, "f"), chunk).then(() => {
-            this.bytesWritten += chunk.byteLength;
-            callback();
-        }).catch((error) => {
-            callback(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-}
-_FileHandleWritable_fileHandle = new WeakMap();
-/**
- * Writes files to a ZIP archive using streaming DEFLATE compression.
- *
- * The implementation intentionally supports ZIP32 archives only. Shapefile
- * components are conventionally limited to 2 GB, but the combined archive can
- * still exceed ZIP32 limits; those cases fail explicitly instead of producing
- * a corrupt archive.
- */
-export default async function writeZip(archive, inputs) {
-    if (inputs.length > maximumZip32Entries) {
-        throw new Error(`ZIP archives support at most ${maximumZip32Entries} files.`);
-    }
-    const fileHandle = await open(archive, "w");
-    const entries = [];
-    let offset = 0;
-    let operationError;
-    try {
-        for (const input of inputs) {
-            const fileStats = await stat(input.file);
-            if (!fileStats.isFile()) {
-                throw new Error(`ZIP input is not a file: ${JSON.stringify(input.file)}`);
-            }
-            assertZip32Value(fileStats.size, "uncompressed file size");
-            const name = encodeZipName(input.name ?? basename(input.file));
-            const { modificationTime, modificationDate } = encodeDosDateTime(fileStats.mtime);
-            const localHeaderOffset = offset;
-            const localHeader = createLocalHeader(name, modificationTime, modificationDate);
-            await writeAll(fileHandle, localHeader);
-            offset += localHeader.byteLength;
-            const checksum = new ChecksumTransform();
-            const output = new FileHandleWritable(fileHandle);
-            await pipeline(createReadStream(input.file), checksum, createDeflateRaw({ level: constants.Z_BEST_SPEED }), output);
-            assertZip32Value(output.bytesWritten, "compressed file size");
-            const descriptor = createDataDescriptor(checksum.crc32, output.bytesWritten, checksum.size);
-            await writeAll(fileHandle, descriptor);
-            offset += output.bytesWritten + descriptor.byteLength;
-            entries.push({
-                name,
-                crc32: checksum.crc32,
-                compressedSize: output.bytesWritten,
-                uncompressedSize: checksum.size,
-                localHeaderOffset,
-                modificationTime,
-                modificationDate,
-            });
-        }
-        const centralDirectoryOffset = offset;
-        for (const entry of entries) {
-            assertZip32Value(entry.localHeaderOffset, "local header offset");
-            const centralHeader = createCentralDirectoryHeader(entry);
-            await writeAll(fileHandle, centralHeader);
-            offset += centralHeader.byteLength;
-        }
-        const centralDirectorySize = offset - centralDirectoryOffset;
-        assertZip32Value(centralDirectoryOffset, "central directory offset");
-        assertZip32Value(centralDirectorySize, "central directory size");
-        await writeAll(fileHandle, createEndOfCentralDirectory(entries.length, centralDirectorySize, centralDirectoryOffset));
-    }
-    catch (error) {
-        operationError = error;
-    }
-    try {
-        await fileHandle.close();
-    }
-    catch (closeError) {
-        if (operationError !== undefined) {
-            operationError = new AggregateError([operationError, closeError], "Writing and closing the ZIP archive both failed.", { cause: operationError });
-        }
-        else {
-            operationError = closeError;
-        }
-    }
-    if (operationError !== undefined) {
-        try {
-            await rm(archive, { force: true });
-        }
-        catch (cleanupError) {
-            throw new AggregateError([operationError, cleanupError], "Writing and cleaning up the ZIP archive both failed.", { cause: operationError });
-        }
-        throw operationError;
-    }
-}
-function createCrc32Table() {
-    const table = new Uint32Array(256);
-    for (let index = 0; index < table.length; index++) {
-        let value = index;
-        for (let bit = 0; bit < 8; bit++) {
-            value = (value & 1) === 1 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
-        }
-        table[index] = value >>> 0;
-    }
-    return table;
-}
-function updateCrc32(data, previous) {
-    if (typeof zlib.crc32 === "function") {
-        return zlib.crc32(data, previous);
-    }
-    let value = (previous ^ 0xffff_ffff) >>> 0;
-    for (const byte of data) {
-        value = crc32Table[(value ^ byte) & 0xff] ^ (value >>> 8);
-    }
-    return (value ^ 0xffff_ffff) >>> 0;
-}
-function encodeZipName(name) {
-    const normalizedName = name.replaceAll("\\", "/");
-    if (normalizedName === "" || normalizedName.startsWith("/") ||
-        normalizedName.split("/").includes("..")) {
-        throw new Error(`Invalid ZIP entry name: ${JSON.stringify(name)}`);
-    }
-    const encoded = new TextEncoder().encode(normalizedName);
-    if (encoded.byteLength > 0xffff) {
-        throw new Error(`ZIP entry name is too long: ${JSON.stringify(name)}`);
-    }
-    return encoded;
-}
-function encodeDosDateTime(date) {
-    const year = Math.min(2107, Math.max(1980, date.getFullYear()));
-    return {
-        modificationTime: (date.getHours() << 11) |
-            (date.getMinutes() << 5) |
-            Math.floor(date.getSeconds() / 2),
-        modificationDate: ((year - 1980) << 9) |
-            ((date.getMonth() + 1) << 5) |
-            date.getDate(),
-    };
-}
-function createLocalHeader(name, modificationTime, modificationDate) {
-    const header = new Uint8Array(30 + name.byteLength);
-    const view = new DataView(header.buffer);
-    view.setUint32(0, 0x0403_4b50, true);
-    view.setUint16(4, 20, true);
-    view.setUint16(6, utf8WithDataDescriptor, true);
-    view.setUint16(8, 8, true);
-    view.setUint16(10, modificationTime, true);
-    view.setUint16(12, modificationDate, true);
-    view.setUint16(26, name.byteLength, true);
-    header.set(name, 30);
-    return header;
-}
-function createDataDescriptor(crc32, compressedSize, uncompressedSize) {
-    const descriptor = new Uint8Array(16);
-    const view = new DataView(descriptor.buffer);
-    view.setUint32(0, 0x0807_4b50, true);
-    view.setUint32(4, crc32, true);
-    view.setUint32(8, compressedSize, true);
-    view.setUint32(12, uncompressedSize, true);
-    return descriptor;
-}
-function createCentralDirectoryHeader(entry) {
-    const header = new Uint8Array(46 + entry.name.byteLength);
-    const view = new DataView(header.buffer);
-    view.setUint32(0, 0x0201_4b50, true);
-    view.setUint16(4, 20, true);
-    view.setUint16(6, 20, true);
-    view.setUint16(8, utf8WithDataDescriptor, true);
-    view.setUint16(10, 8, true);
-    view.setUint16(12, entry.modificationTime, true);
-    view.setUint16(14, entry.modificationDate, true);
-    view.setUint32(16, entry.crc32, true);
-    view.setUint32(20, entry.compressedSize, true);
-    view.setUint32(24, entry.uncompressedSize, true);
-    view.setUint16(28, entry.name.byteLength, true);
-    view.setUint32(42, entry.localHeaderOffset, true);
-    header.set(entry.name, 46);
-    return header;
-}
-function createEndOfCentralDirectory(entryCount, centralDirectorySize, centralDirectoryOffset) {
-    const end = new Uint8Array(22);
-    const view = new DataView(end.buffer);
-    view.setUint32(0, 0x0605_4b50, true);
-    view.setUint16(8, entryCount, true);
-    view.setUint16(10, entryCount, true);
-    view.setUint32(12, centralDirectorySize, true);
-    view.setUint32(16, centralDirectoryOffset, true);
-    return end;
-}
-function assertZip32Value(value, label) {
-    if (!Number.isSafeInteger(value) || value < 0 || value > maximumZip32Value) {
-        throw new Error(`Cannot create ZIP archive: ${label} exceeds the 4 GB ZIP32 limit.`);
-    }
-}
-async function writeAll(fileHandle, data) {
-    let offset = 0;
-    while (offset < data.byteLength) {
-        const { bytesWritten } = await fileHandle.write(data.subarray(offset));
-        if (bytesWritten === 0) {
-            throw new Error("Could not write to ZIP archive.");
-        }
-        offset += bytesWritten;
-    }
-}

package/esm/index.d.ts

@@ -1,35 +0,0 @@
-/**
- * @module
- *
- * The Simple Data Analysis (Core) Library
- *
- * To install the library with Deno, use:
- * ```bash
- * deno add jsr:@nshiab/simple-data-analysis-core
- * ```
- *
- * To install the library with Node.js, use:
- * ```bash
- * npm i @nshiab/simple-data-analysis-core
- * ```
- *
- * To start, create a SimpleDB instance and then a SimpleTable from this instance:
- * ```ts
- * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
- *
- * const sdb = new SimpleDB();
- * const table = await sdb
- *   .newTable("myTable")
- *   .loadData("path/to/your/data.csv")
- *   .log();
- *
- * // You can now perform various data analysis operations on the table.
- *
- * await sdb.close(); // Ensure to close the database when you're finished.
- * ```
- */
-import "./_dnt.polyfills.js";
-export { default as SimpleDB } from "./class/SimpleDB.js";
-export { default as SimpleTable } from "./class/SimpleTable.js";
-export { default as SDAError } from "./class/SDAError.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/esm/index.js

@@ -1,34 +0,0 @@
-/**
- * @module
- *
- * The Simple Data Analysis (Core) Library
- *
- * To install the library with Deno, use:
- * ```bash
- * deno add jsr:@nshiab/simple-data-analysis-core
- * ```
- *
- * To install the library with Node.js, use:
- * ```bash
- * npm i @nshiab/simple-data-analysis-core
- * ```
- *
- * To start, create a SimpleDB instance and then a SimpleTable from this instance:
- * ```ts
- * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
- *
- * const sdb = new SimpleDB();
- * const table = await sdb
- *   .newTable("myTable")
- *   .loadData("path/to/your/data.csv")
- *   .log();
- *
- * // You can now perform various data analysis operations on the table.
- *
- * await sdb.close(); // Ensure to close the database when you're finished.
- * ```
- */
-import "./_dnt.polyfills.js";
-export { default as SimpleDB } from "./class/SimpleDB.js";
-export { default as SimpleTable } from "./class/SimpleTable.js";
-export { default as SDAError } from "./class/SDAError.js";

package/esm/methods/accumulate.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"accumulate.d.ts","sourceRoot":"","sources":["../../src/methods/accumulate.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,QA8BP"}

package/esm/methods/accumulate.js

@@ -1,37 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import stringToArray from "../helpers/stringToArray.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-export default function accumulate(simpleTable, column, newColumn, options = {}) {
-    // The accumulation order is based on rowid, which only exists on the
-    // materialized table, not on the output of a fused step: it executes as a
-    // barrier.
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "barrier",
-        method: "accumulate()",
-        parameters: { column, newColumn, options },
-        execute: async () => {
-            // A SELECT *, expr AS col colliding with an existing column would be
-            // silently renamed by DuckDB (col -> col_1) instead of erroring.
-            assertNewColumns(await simpleTable.getTypes(), [newColumn], "accumulate()");
-            await queryDB(simpleTable, accumulateQuery(simpleTable.name, column, newColumn, options), mergeOptions(simpleTable, {
-                table: simpleTable.name,
-                method: "accumulate()",
-                parameters: { column, newColumn, options },
-            }));
-        },
-    });
-}
-function accumulateQuery(table, column, newColumn, options = {}) {
-    const by = options.by ? stringToArray(options.by) : [];
-    const partition = by.length > 0
-        ? `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")} `
-        : "";
-    const query = `CREATE OR REPLACE TABLE ${quoteIdentifier(table)} AS SELECT *, SUM(${quoteIdentifier(column)}) OVER (${partition}ORDER BY rowid) AS ${quoteIdentifier(newColumn)}
-    FROM ${quoteIdentifier(table)}
-    ORDER BY rowid;`;
-    return query;
-}

package/esm/methods/addBoundingBox.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"addBoundingBox.d.ts","sourceRoot":"","sources":["../../src/methods/addBoundingBox.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,QAwBP"}

package/esm/methods/addBoundingBox.js

@@ -1,26 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-export default function addBoundingBox(simpleTable, options = {}) {
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "addBoundingBox()",
-        parameters: { options },
-        needsSchema: true,
-        needsSpatial: true,
-        buildSelect: (input, types) => {
-            const column = options.column ??
-                findGeoColumnFromSchema(types, "addBoundingBox()", simpleTable.name);
-            const round = (expression) => typeof options.decimals === "number"
-                ? `ROUND(${expression}, ${options.decimals})`
-                : expression;
-            return `SELECT *,
-    ${round(`ST_XMin(${quoteIdentifier(column)})`)} AS minLon,
-    ${round(`ST_YMin(${quoteIdentifier(column)})`)} AS minLat,
-    ${round(`ST_XMax(${quoteIdentifier(column)})`)} AS maxLon,
-    ${round(`ST_YMax(${quoteIdentifier(column)})`)} AS maxLat
-    FROM ${input}`;
-        },
-    });
-}

package/esm/methods/addCharacterCount.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"addCharacterCount.d.ts","sourceRoot":"","sources":["../../src/methods/addCharacterCount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,QAclB"}

package/esm/methods/addCharacterCount.js

@@ -1,15 +0,0 @@
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-export default function addCharacterCount(simpleTable, column, newColumn) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "addCharacterCount()",
-        parameters: { column, newColumn },
-        needsSchema: true,
-        buildSelect: (input, types) => {
-            assertNewColumns(types, [newColumn], "addCharacterCount()");
-            return `SELECT *, LENGTH(${quoteIdentifier(column)}) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/addColumn.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function addColumn(simpleTable: SimpleTable, newColumn: string, type: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean" | "json" | "JSON" | `float[${number}]` | `FLOAT[${number}]` | `geometry('${string}')` | `GEOMETRY('${string}')`, definition: string): void;
-//# sourceMappingURL=addColumn.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"addColumn.d.ts","sourceRoot":"","sources":["../../src/methods/addColumn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EACA,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,MAAM,GACN,MAAM,GACN,SAAS,MAAM,GAAG,GAClB,SAAS,MAAM,GAAG,GAClB,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,EAC3B,UAAU,EAAE,MAAM,QAuBnB"}

package/esm/methods/addColumn.js

@@ -1,24 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import parseType from "../helpers/parseTypes.js";
-export default function addColumn(simpleTable, newColumn, type, definition) {
-    const newType = parseType(type);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "addColumn()",
-        parameters: { newColumn, type, definition },
-        // The schema is needed to reject a duplicate column, as v1's ALTER TABLE
-        // ADD did.
-        needsSchema: true,
-        // A geometry column needs the spatial extension, both to cast to the
-        // GEOMETRY type and for the spatial functions in the definition.
-        needsSpatial: newType.toLowerCase().includes("geometry"),
-        rawSQL: [definition],
-        outputSchema: (types) => ({ ...types, [newColumn]: newType }),
-        buildSelect: (input, types) => {
-            assertNewColumns(types, [newColumn], "addColumn()");
-            return `SELECT *, CAST((${definition}) AS ${newType}) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/addGeoClosedStatus.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"addGeoClosedStatus.d.ts","sourceRoot":"","sources":["../../src/methods/addGeoClosedStatus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,QAuBlC"}

package/esm/methods/addGeoClosedStatus.js

@@ -1,21 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-export default function addGeoClosedStatus(simpleTable, newColumn, options = {}) {
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "addGeoClosedStatus()",
-        parameters: { newColumn, options },
-        needsSchema: true,
-        needsSpatial: true,
-        buildSelect: (input, types) => {
-            assertNewColumns(types, [newColumn], "addGeoClosedStatus()");
-            const column = typeof options.column === "string"
-                ? options.column
-                : findGeoColumnFromSchema(types, "addGeoClosedStatus()", simpleTable.name);
-            return `SELECT *, CAST(ST_IsClosed(${quoteIdentifier(column)}) AS BOOLEAN) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/addGeoNoise.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function addGeoNoise(simpleTable: SimpleTable, maxDistance: number, options?: {
-    column?: string;
-    unit?: "m" | "km";
-    onlyDuplicates?: boolean;
-}): void;
-//# sourceMappingURL=addGeoNoise.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"addGeoNoise.d.ts","sourceRoot":"","sources":["../../src/methods/addGeoNoise.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CACrB,QA2CP"}

package/esm/methods/addGeoNoise.js

@@ -1,135 +0,0 @@
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-// This is the mean Earth radius used by DuckDB's ST_Distance_Sphere().
-const EARTH_RADIUS_METERS = 6_371_000;
-export default function addGeoNoise(simpleTable, maxDistance, options = {}) {
-    // This validation doesn't need the database, so it stays at call time.
-    if (!Number.isFinite(maxDistance) || maxDistance < 0) {
-        throw new Error("addGeoNoise() maxDistance must be a finite number greater than or equal to 0.");
-    }
-    if (options.unit !== undefined && options.unit !== "m" && options.unit !== "km") {
-        throw new Error('addGeoNoise() options.unit must be "m" or "km".');
-    }
-    options = structuredClone(options);
-    const maxDistanceMeters = options.unit === "km"
-        ? maxDistance * 1_000
-        : maxDistance;
-    if (maxDistanceMeters > Math.PI * EARTH_RADIUS_METERS) {
-        throw new Error("addGeoNoise() maxDistance cannot exceed half the Earth's circumference.");
-    }
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "addGeoNoise()",
-        parameters: { maxDistance, options },
-        needsSchema: true,
-        needsSpatial: true,
-        preservesSchema: true,
-        buildSelect: (input, schema) => {
-            const column = options.column ??
-                findGeoColumnFromSchema(schema, "addGeoNoise()", simpleTable.name);
-            return addGeoNoiseSelect(input, schema, column, maxDistanceMeters, options.onlyDuplicates === true);
-        },
-    });
-}
-function addGeoNoiseSelect(input, schema, column, maxDistanceMeters, onlyDuplicates) {
-    const type = schema[column];
-    if (type === undefined) {
-        throw new Error(`addGeoNoise() could not find column ${quoteIdentifier(column)}.`);
-    }
-    if (type !== "GEOMETRY('EPSG:4326')") {
-        throw new Error(`addGeoNoise() requires an EPSG:4326 geometry column, but ${quoteIdentifier(column)} has type ${type}. Reproject it to EPSG:4326 first.`);
-    }
-    const internalNames = makeInternalNames(schema, input);
-    const quotedColumn = quoteIdentifier(column);
-    const pointError = `error('addGeoNoise() requires POINT geometries in column ${column.replaceAll("'", "''")}.')`;
-    const coordinateGuard = (coordinate) => `CASE
-    WHEN ${quotedColumn} IS NULL OR ST_IsEmpty(${quotedColumn}) THEN NULL
-    WHEN CAST(ST_GeometryType(${quotedColumn}) AS VARCHAR) <> 'POINT'
-      THEN ${pointError}
-    ELSE radians(ST_${coordinate}(${quotedColumn}))
-  END`;
-    const duplicateCount = onlyDuplicates
-        ? `COUNT(*) OVER (PARTITION BY ${quotedColumn})`
-        : "2";
-    const maxAngularDistance = maxDistanceMeters / EARTH_RADIUS_METERS;
-    const latitudeExpression = `asin(
-    sin(${quoteIdentifier(internalNames.latitude)}) * cos(${quoteIdentifier(internalNames.angularDistance)}) +
-    cos(${quoteIdentifier(internalNames.latitude)}) * sin(${quoteIdentifier(internalNames.angularDistance)}) * cos(${quoteIdentifier(internalNames.bearing)})
-  )`;
-    const longitudeExpression = `${quoteIdentifier(internalNames.longitude)} + atan2(
-    sin(${quoteIdentifier(internalNames.bearing)}) * sin(${quoteIdentifier(internalNames.angularDistance)}) * cos(${quoteIdentifier(internalNames.latitude)}),
-    cos(${quoteIdentifier(internalNames.angularDistance)}) -
-      sin(${quoteIdentifier(internalNames.latitude)}) * sin(${quoteIdentifier(internalNames.destinationLatitude)})
-  )`;
-    const replacement = `CASE
-    WHEN ${quotedColumn} IS NULL OR ST_IsEmpty(${quotedColumn}) THEN ${quotedColumn}
-    WHEN ${quoteIdentifier(internalNames.duplicateCount)} <= 1 THEN ${quotedColumn}
-    ELSE ST_Point(
-      degrees(atan2(
-        sin(${quoteIdentifier(internalNames.destinationLongitude)}),
-        cos(${quoteIdentifier(internalNames.destinationLongitude)})
-      )),
-      degrees(${quoteIdentifier(internalNames.destinationLatitude)})
-    )::GEOMETRY('EPSG:4326')
-  END AS ${quotedColumn}`;
-    const outputColumns = Object.keys(schema).map((outputColumn) => outputColumn === column ? replacement : quoteIdentifier(outputColumn)).join(", ");
-    return `WITH ${quoteIdentifier(internalNames.randomValues)} AS MATERIALIZED (
-    SELECT *,
-      random() AS ${quoteIdentifier(internalNames.distanceRandom)},
-      random() AS ${quoteIdentifier(internalNames.bearingRandom)},
-      ${duplicateCount} AS ${quoteIdentifier(internalNames.duplicateCount)}
-    FROM ${input}
-  ),
-  ${quoteIdentifier(internalNames.start)} AS (
-    SELECT *,
-      ${coordinateGuard("Y")} AS ${quoteIdentifier(internalNames.latitude)},
-      ${coordinateGuard("X")} AS ${quoteIdentifier(internalNames.longitude)},
-      2 * pi() * ${quoteIdentifier(internalNames.bearingRandom)} AS ${quoteIdentifier(internalNames.bearing)},
-      2 * asin(
-        sqrt(${quoteIdentifier(internalNames.distanceRandom)}) *
-        sin(${maxAngularDistance} / 2)
-      ) AS ${quoteIdentifier(internalNames.angularDistance)}
-    FROM ${quoteIdentifier(internalNames.randomValues)}
-  ),
-  ${quoteIdentifier(internalNames.destinationLatitudeCte)} AS (
-    SELECT *, ${latitudeExpression} AS ${quoteIdentifier(internalNames.destinationLatitude)}
-    FROM ${quoteIdentifier(internalNames.start)}
-  ),
-  ${quoteIdentifier(internalNames.destination)} AS (
-    SELECT *, ${longitudeExpression} AS ${quoteIdentifier(internalNames.destinationLongitude)}
-    FROM ${quoteIdentifier(internalNames.destinationLatitudeCte)}
-  )
-  SELECT ${outputColumns}
-  FROM ${quoteIdentifier(internalNames.destination)}`;
-}
-function makeInternalNames(schema, input) {
-    const used = new Set(Object.keys(schema));
-    if (input.startsWith('"') && input.endsWith('"')) {
-        used.add(input.slice(1, -1).replaceAll('""', '"'));
-    }
-    const next = (base) => {
-        let name = base;
-        let suffix = 2;
-        while (used.has(name)) {
-            name = `${base}_${suffix++}`;
-        }
-        used.add(name);
-        return name;
-    };
-    return {
-        randomValues: next("__sda_add_geo_noise_random_values"),
-        start: next("__sda_add_geo_noise_start"),
-        destinationLatitudeCte: next("__sda_add_geo_noise_latitude_result"),
-        destination: next("__sda_add_geo_noise_result"),
-        distanceRandom: next("__sda_add_geo_noise_distance_random"),
-        bearingRandom: next("__sda_add_geo_noise_bearing_random"),
-        duplicateCount: next("__sda_add_geo_noise_duplicate_count"),
-        latitude: next("__sda_add_geo_noise_latitude"),
-        longitude: next("__sda_add_geo_noise_longitude"),
-        bearing: next("__sda_add_geo_noise_bearing"),
-        angularDistance: next("__sda_add_geo_noise_angular_distance"),
-        destinationLatitude: next("__sda_add_geo_noise_destination_latitude"),
-        destinationLongitude: next("__sda_add_geo_noise_destination_longitude"),
-    };
-}