@nshiab/simple-data-analysis-core 1.0.1 → 2.0.0

package/esm/helpers/writeZip.js

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

@@ -10,7 +10,7 @@
  *
  * To install the library with Node.js, use:
  * ```bash
- * npx jsr add @nshiab/simple-data-analysis-core
+ * npm i @nshiab/simple-data-analysis-core
  * ```
  *
  * To start, create a SimpleDB instance and then a SimpleTable from this instance:
@@ -18,14 +18,18 @@
  * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
  *
  * const sdb = new SimpleDB();
- * const table = sdb.newTable("myTable"); // This returns a SimpleTable instance
- * await table.loadData("path/to/your/data.csv");
+ * 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.done(); // Ensure to call done when you're finished.
+ * 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 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC"}
+{"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

@@ -10,7 +10,7 @@
  *
  * To install the library with Node.js, use:
  * ```bash
- * npx jsr add @nshiab/simple-data-analysis-core
+ * npm i @nshiab/simple-data-analysis-core
  * ```
  *
  * To start, create a SimpleDB instance and then a SimpleTable from this instance:
@@ -18,13 +18,17 @@
  * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
  *
  * const sdb = new SimpleDB();
- * const table = sdb.newTable("myTable"); // This returns a SimpleTable instance
- * await table.loadData("path/to/your/data.csv");
+ * 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.done(); // Ensure to call done when you're finished.
+ * 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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+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/addColumn.d.ts

@@ -0,0 +1,3 @@
+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" | `geometry('${string}')` | `GEOMETRY('${string}')`, definition: string): void;
+//# sourceMappingURL=addColumn.d.ts.map

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

@@ -0,0 +1 @@
+{"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,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,EAC3B,UAAU,EAAE,MAAM,QAuBnB"}

package/esm/methods/addColumn.js

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,21 @@
+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/addGeoType.d.ts

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

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

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

package/esm/methods/addGeoType.js

@@ -0,0 +1,21 @@
+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 addGeoType(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "addGeoType()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "addGeoType()");
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "addGeoType()", simpleTable.name);
+            return `SELECT *, CAST(ST_GeometryType(${quoteIdentifier(column)}) AS VARCHAR) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/addGeoValidity.d.ts

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

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

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

package/esm/methods/addGeoValidity.js

@@ -0,0 +1,21 @@
+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 addGeoValidity(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "addGeoValidity()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "addGeoValidity()");
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "addGeoValidity()", simpleTable.name);
+            return `SELECT *, CAST(ST_IsValid(${quoteIdentifier(column)}) AS BOOLEAN) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/addRowNumber.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"addRowNumber.d.ts","sourceRoot":"","sources":["../../src/methods/addRowNumber.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAO,QA8BzC"}

package/esm/methods/addRowNumber.js

@@ -0,0 +1,26 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import stringToArray from "../helpers/stringToArray.js";
+export default function addRowNumber(simpleTable, newColumn, options = {}) {
+    // The row number 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: "addRowNumber()",
+        parameters: { newColumn, options },
+        execute: async () => {
+            const by = options.by ? stringToArray(options.by) : [];
+            const partition = by.length > 0
+                ? `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")}`
+                : "";
+            await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT *, (ROW_NUMBER() OVER(${partition} ORDER BY rowid) - 1) AS ${quoteIdentifier(newColumn)} FROM ${quoteIdentifier(simpleTable.name)} ORDER BY rowid`, mergeOptions(simpleTable, {
+                table: simpleTable.name,
+                method: "addRowNumber()",
+                parameters: { newColumn, options },
+            }));
+        },
+    });
+}

package/esm/methods/addSummaryRows.d.ts

@@ -0,0 +1,14 @@
+import { type Stat } from "../helpers/getStatExpression.js";
+import type SimpleTable from "../class/SimpleTable.js";
+type StatRowOperation = Exclude<Stat, "count">;
+type StatRow = StatRowOperation | {
+    stat: StatRowOperation;
+    label?: string;
+};
+type AddSummaryRowsOptions = {
+    stats?: StatRow | StatRow[];
+    position?: "top" | "bottom";
+};
+export default function addSummaryRows(simpleTable: SimpleTable, columns: "all" | string | string[], labelColumn: string, options?: AddSummaryRowsOptions): void;
+export {};
+//# sourceMappingURL=addSummaryRows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addSummaryRows.d.ts","sourceRoot":"","sources":["../../src/methods/addSummaryRows.ts"],"names":[],"mappings":"AACA,OAA0B,EAExB,KAAK,IAAI,EACV,MAAM,iCAAiC,CAAC;AAMzC,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,KAAK,gBAAgB,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/C,KAAK,OAAO,GACR,gBAAgB,GAChB;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C,KAAK,qBAAqB,GAAG;IAC3B,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE,CAAC;IAC5B,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CAC7B,CAAC;AAMF,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE,EAClC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,qBAA0B,QAyDpC"}