@nshiab/simple-data-analysis 5.21.0 → 6.0.0

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/queueAsyncBarrier.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueAsyncBarrier;
+const queueOp_js_1 = __importDefault(require("./queueOp.js"));
+/**
+ * Queues asynchronous extension work as one ordered table-builder step.
+ * Builder operations queued by `execute` are scoped to the barrier and drain
+ * before its observer queries and before later chained operations.
+ *
+ * `execute` must await all asynchronous work that can queue table operations.
+ * Detached work is outside the barrier's program-order scope.
+ *
+ * If `execute` rejects, captured builder operations that have not already
+ * drained are discarded. Operations drained by an observer inside `execute`
+ * remain applied; an asynchronous barrier does not provide database rollback.
+ *
+ * @param simpleTable - The table whose chain owns the asynchronous work.
+ * @param operation - The asynchronous extension operation to queue.
+ * @param operation.method - The public method name used for diagnostics.
+ * @param operation.parameters - A snapshot of the public method parameters used for diagnostics.
+ * @param operation.execute - The asynchronous work to run at the barrier's position in the chain.
+ * @returns Nothing. The public builder should return its target table.
+ *
+ * @example
+ * ```ts
+ * import type { SimpleTable } from "@nshiab/simple-data-analysis-core";
+ * import { queueAsyncBarrier } from "@nshiab/simple-data-analysis-core/helpers";
+ *
+ * function loadRemote(table: SimpleTable, url: string): SimpleTable {
+ *   queueAsyncBarrier(table, {
+ *     method: "loadRemote()",
+ *     parameters: { url },
+ *     execute: async () => {
+ *       const rows = await fetch(url).then((response) => response.json()) as
+ *         { [key: string]: unknown }[];
+ *       table.loadArray(rows);
+ *     },
+ *   });
+ *   return table;
+ * }
+ * ```
+ */
+function queueAsyncBarrier(simpleTable, operation) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "asyncBarrier",
+        ...operation,
+    });
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/queueOp.d.ts

@@ -0,0 +1,18 @@
+import type SimpleDB from "../class/SimpleDB.js";
+import type SimpleTable from "../class/SimpleTable.js";
+import type { PendingOpInput } from "./pendingOps.js";
+/**
+ * Queues an internal relational operation, barrier, or asynchronous barrier.
+ *
+ * @internal
+ */
+export default function queueOp(simpleTable: SimpleTable, op: PendingOpInput): void;
+/**
+ * Empties every table's pending queue without executing it and returns what
+ * was dropped, so close() can report forgotten work after cleaning up.
+ */
+export declare function discardAllPending(sdb: SimpleDB): {
+    table: SimpleTable;
+    methods: string[];
+}[];
+//# sourceMappingURL=queueOp.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/queueOp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queueOp.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/queueOp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMtD;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,WAAW,EAAE,WAAW,EACxB,EAAE,EAAE,cAAc,GACjB,IAAI,CA8CN;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,QAAQ,GACZ;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,CAa7C"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/queueOp.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueOp;
+exports.discardAllPending = discardAllPending;
+const tableRegistry_js_1 = require("./tableRegistry.js");
+const tableGeneration_js_1 = require("./tableGeneration.js");
+const cacheTableDependencies_js_1 = require("./cacheTableDependencies.js");
+const asyncOperationContext_js_1 = require("./asyncOperationContext.js");
+/**
+ * Queues an internal relational operation, barrier, or asynchronous barrier.
+ *
+ * @internal
+ */
+function queueOp(simpleTable, op) {
+    const sdb = simpleTable.sdb;
+    if (sdb.lifecycleState !== "open") {
+        throw new Error(`${op.method} cannot queue work because its SimpleDB is ${sdb.lifecycleState}.`);
+    }
+    let capturedOp = {
+        ...op,
+        parameters: op.parameters === null ? null : structuredClone(op.parameters),
+    };
+    if (capturedOp.kind === "fusable" || capturedOp.kind === "source") {
+        capturedOp = {
+            ...capturedOp,
+            rawSQL: capturedOp.rawSQL === undefined
+                ? undefined
+                : [...capturedOp.rawSQL],
+        };
+        if (capturedOp.rawSQL !== undefined) {
+            (0, cacheTableDependencies_js_1.recordCacheTableReferences)(simpleTable, capturedOp.rawSQL);
+        }
+    }
+    if (capturedOp.kind === "fusable" &&
+        capturedOp.values !== undefined &&
+        typeof capturedOp.values !== "function") {
+        capturedOp = {
+            ...capturedOp,
+            values: [...capturedOp.values],
+        };
+    }
+    // A table de-registered by removeTable()/removeTables()/selectTables() that
+    // queues new work comes back under the flush's responsibility, like v1
+    // methods recreating a removed table.
+    (0, tableRegistry_js_1.ensureTableRegistered)(sdb, simpleTable);
+    (0, tableGeneration_js_1.markTableChanged)(simpleTable);
+    const queuedOp = {
+        ...capturedOp,
+        sequence: sdb.opSequence++,
+    };
+    if ((0, asyncOperationContext_js_1.captureAsyncOperation)(sdb, { table: simpleTable, op: queuedOp })) {
+        return;
+    }
+    simpleTable.pendingOps.push(queuedOp);
+    sdb.pendingCount++;
+}
+/**
+ * Empties every table's pending queue without executing it and returns what
+ * was dropped, so close() can report forgotten work after cleaning up.
+ */
+function discardAllPending(sdb) {
+    const discarded = [];
+    for (const table of (0, tableRegistry_js_1.getRegisteredTables)(sdb)) {
+        if (table.pendingOps.length > 0) {
+            discarded.push({
+                table,
+                methods: table.pendingOps.map((op) => op.method),
+            });
+            sdb.pendingCount -= table.pendingOps.length;
+            table.pendingOps.length = 0;
+        }
+    }
+    return discarded;
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteIdentifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Quotes one SQL identifier and escapes embedded double quotes.
+ * Use this for library-generated table, column, schema, database, and alias
+ * names. User-authored SQL expressions must remain unmodified.
+ *
+ * @param identifier - The identifier to quote.
+ * @returns The identifier wrapped in double quotes with embedded quotes doubled.
+ *
+ * @example
+ * ```ts
+ * quoteIdentifier('people "archive"');
+ * // '"people ""archive"""'
+ * ```
+ */
+export default function quoteIdentifier(identifier: string): string;
+//# sourceMappingURL=quoteIdentifier.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quoteIdentifier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteIdentifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteIdentifier.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = quoteIdentifier;
+/**
+ * Quotes one SQL identifier and escapes embedded double quotes.
+ * Use this for library-generated table, column, schema, database, and alias
+ * names. User-authored SQL expressions must remain unmodified.
+ *
+ * @param identifier - The identifier to quote.
+ * @returns The identifier wrapped in double quotes with embedded quotes doubled.
+ *
+ * @example
+ * ```ts
+ * quoteIdentifier('people "archive"');
+ * // '"people ""archive"""'
+ * ```
+ */
+function quoteIdentifier(identifier) {
+    return `"${identifier.replaceAll('"', '""')}"`;
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteQualifiedIdentifier.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Quotes a SQL identifier together with the relation that owns it.
+ *
+ * Qualifying column references prevents DuckDB from resolving a relation name
+ * as its row struct when a missing column has the same name as the relation.
+ *
+ * @param relation - The table or relation containing the identifier.
+ * @param identifier - The identifier to qualify.
+ * @returns The separately quoted relation and identifier joined by a period.
+ *
+ * @example
+ * ```ts
+ * quoteQualifiedIdentifier("people", "full name");
+ * // '"people"."full name"'
+ * ```
+ */
+export default function quoteQualifiedIdentifier(relation: string, identifier: string): string;
+//# sourceMappingURL=quoteQualifiedIdentifier.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteQualifiedIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quoteQualifiedIdentifier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteQualifiedIdentifier.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,MAAM,CAER"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/quoteQualifiedIdentifier.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = quoteQualifiedIdentifier;
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+/**
+ * Quotes a SQL identifier together with the relation that owns it.
+ *
+ * Qualifying column references prevents DuckDB from resolving a relation name
+ * as its row struct when a missing column has the same name as the relation.
+ *
+ * @param relation - The table or relation containing the identifier.
+ * @param identifier - The identifier to qualify.
+ * @returns The separately quoted relation and identifier joined by a period.
+ *
+ * @example
+ * ```ts
+ * quoteQualifiedIdentifier("people", "full name");
+ * // '"people"."full name"'
+ * ```
+ */
+function quoteQualifiedIdentifier(relation, identifier) {
+    return `${(0, quoteIdentifier_js_1.default)(relation)}.${(0, quoteIdentifier_js_1.default)(identifier)}`;
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/readDbMetadata.d.ts

@@ -0,0 +1,5 @@
+import type SimpleDB from "../class/SimpleDB.js";
+import type { IndexDefinition } from "./indexDefinitions.js";
+/** Reads embedded SDA metadata when present. */
+export default function readDbMetadata(sdb: SimpleDB, database: string): Promise<Record<string, IndexDefinition[]>>;
+//# sourceMappingURL=readDbMetadata.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/readDbMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDbMetadata.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/readDbMetadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,gDAAgD;AAChD,wBAA8B,cAAc,CAC1C,GAAG,EAAE,QAAQ,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC,CA0B5C"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/readDbMetadata.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = readDbMetadata;
+const queryDbFile_js_1 = __importDefault(require("./queryDbFile.js"));
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+const parseValue_js_1 = __importDefault(require("./parseValue.js"));
+/** Reads embedded SDA metadata when present. */
+async function readDbMetadata(sdb, database) {
+    const schemas = await (0, queryDbFile_js_1.default)(sdb, `SELECT schema_name FROM duckdb_schemas()
+     WHERE database_name = ${(0, parseValue_js_1.default)(database)} AND schema_name = '__sda';`, { returnData: true });
+    if (schemas.length > 0) {
+        const rows = await (0, queryDbFile_js_1.default)(sdb, `SELECT version, indexes FROM ${(0, quoteIdentifier_js_1.default)(database)}.__sda.metadata;`, { returnData: true });
+        if (rows.length !== 1 || rows[0].version !== 1 ||
+            typeof rows[0].indexes !== "string") {
+            throw new Error("Unsupported SDA database metadata in the reserved __sda schema.");
+        }
+        return validateIndexes(JSON.parse(rows[0].indexes));
+    }
+    return {};
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateIndexes(value) {
+    if (!isRecord(value))
+        throw new Error("Invalid SDA index metadata.");
+    for (const definitions of Object.values(value)) {
+        if (!Array.isArray(definitions)) {
+            throw new Error("Invalid SDA index metadata.");
+        }
+        for (const definition of definitions) {
+            if (!isRecord(definition) || typeof definition.name !== "string" ||
+                !isRecord(definition.options)) {
+                throw new Error("Invalid SDA index definition.");
+            }
+            const options = definition.options;
+            if (definition.kind === "fts") {
+                if (typeof definition.idColumn !== "string" ||
+                    typeof definition.textColumn !== "string" ||
+                    ["stemmer", "stopwords", "ignore"].some((key) => options[key] !== undefined && typeof options[key] !== "string") ||
+                    ["stripAccents", "lower"].some((key) => options[key] !== undefined && typeof options[key] !== "boolean")) {
+                    throw new Error("Invalid SDA FTS index definition.");
+                }
+            }
+            else if (definition.kind === "vss") {
+                if (typeof definition.column !== "string" ||
+                    ["efConstruction", "efSearch", "M"].some((key) => options[key] !== undefined &&
+                        (typeof options[key] !== "number" || !Number.isFinite(options[key])))) {
+                    throw new Error("Invalid SDA VSS index definition.");
+                }
+            }
+            else {
+                throw new Error("Unsupported SDA index definition.");
+            }
+        }
+    }
+    return value;
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/removeColumnsNow.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+/**
+ * Drops columns immediately, without queueing. For use inside a barrier's
+ * execute, which runs during a flush: a sync builder method called there
+ * would queue an operation for the next flush instead of running now.
+ */
+export default function removeColumnsNow(simpleTable: SimpleTable, columns: string[], method: string): Promise<void>;
+//# sourceMappingURL=removeColumnsNow.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/removeColumnsNow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeColumnsNow.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/removeColumnsNow.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;GAIG;AACH,wBAA8B,gBAAgB,CAC5C,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/removeColumnsNow.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = removeColumnsNow;
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+const mergeOptions_js_1 = __importDefault(require("./mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("./queryDB.js"));
+/**
+ * Drops columns immediately, without queueing. For use inside a barrier's
+ * execute, which runs during a flush: a sync builder method called there
+ * would queue an operation for the next flush instead of running now.
+ */
+async function removeColumnsNow(simpleTable, columns, method) {
+    await (0, queryDB_js_1.default)(simpleTable, columns.map((d) => `ALTER TABLE ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} DROP ${(0, quoteIdentifier_js_1.default)(d)};`).join("\n"), (0, mergeOptions_js_1.default)(simpleTable, {
+        table: simpleTable.name,
+        method,
+        parameters: { columns },
+    }));
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/resolveOutputTable.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+/**
+ * Resolves `outputTable: true` into an auto-generated table name
+ * ("table0", "table1", ...), incrementing the database's shared counter so
+ * concurrent auto-named tables never collide. A string, `false`, or
+ * `undefined` value passes through unchanged.
+ */
+export default function resolveOutputTable(simpleTable: SimpleTable, outputTable: string | boolean | undefined): string | boolean | undefined;
+//# sourceMappingURL=resolveOutputTable.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/resolveOutputTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveOutputTable.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/resolveOutputTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,GACxC,MAAM,GAAG,OAAO,GAAG,SAAS,CAO9B"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/resolveOutputTable.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = resolveOutputTable;
+/**
+ * Resolves `outputTable: true` into an auto-generated table name
+ * ("table0", "table1", ...), incrementing the database's shared counter so
+ * concurrent auto-named tables never collide. A string, `false`, or
+ * `undefined` value passes through unchanged.
+ */
+function resolveOutputTable(simpleTable, outputTable) {
+    if (outputTable === true) {
+        const name = `table${simpleTable.sdb.tableIncrement}`;
+        simpleTable.sdb.tableIncrement += 1;
+        return name;
+    }
+    return outputTable;
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/rewind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/rewind.ts"],"names":[],"mappings":"AA0mCA,iBAAS,MAAM,CAAC,OAAO,KAAA,OAiBtB;AAiHD,OAAO,EACL,MAAM,IAAI,OAAO,EAClB,CAAC"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/runQuery.d.ts

@@ -0,0 +1,17 @@
+import { type DuckDBConnection, type DuckDBType, type DuckDBValue } from "@duckdb/node-api";
+type RunQueryOptions = {
+    method: string | null;
+    parameters: {
+        [key: string]: unknown;
+    } | null;
+    table?: string | null;
+    values?: DuckDBValue[];
+    logSQL: boolean;
+    explainSQL: boolean;
+};
+export declare function makeConverter(type: DuckDBType, columnName: string, tableName?: string | null): (value: DuckDBValue) => unknown;
+export default function runQuery(query: string, connection: DuckDBConnection, returnData: boolean, options: RunQueryOptions): Promise<{
+    [key: string]: unknown;
+}[] | null>;
+export {};
+//# sourceMappingURL=runQuery.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/runQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runQuery.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/runQuery.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,gBAAgB,EAIrB,KAAK,UAAU,EAEf,KAAK,WAAW,EAIjB,MAAM,kBAAkB,CAAC;AAI1B,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9C,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAqDF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,MAAM,GAAG,IAAW,GAC9B,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAsCjC;AAED,wBAA8B,QAAQ,CACpC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,gBAAgB,EAC5B,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,eAAe,GACvB,OAAO,CACN;IACA,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,EAAE,GACD,IAAI,CACP,CA6DA"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/runQuery.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConverter = makeConverter;
+exports.default = runQuery;
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+const node_api_1 = require("@duckdb/node-api");
+const SDAError_js_1 = __importDefault(require("../class/SDAError.js"));
+const observeQuery_js_1 = __importDefault(require("./observeQuery.js"));
+const msPerDay = 24 * 60 * 60 * 1000;
+const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
+const minSafeInteger = BigInt(Number.MIN_SAFE_INTEGER);
+// Columns already warned about for precision loss (keyed by table and
+// column), so each column warns only once.
+const warnedUnsafeIntegerColumns = new Set();
+function makeIntegerConverter(columnName, tableName) {
+    const warnKey = `${tableName ?? ""}\0${columnName}`;
+    return (value) => {
+        if (value === null) {
+            return null;
+        }
+        const bigintValue = value;
+        if ((bigintValue > maxSafeInteger || bigintValue < minSafeInteger) &&
+            !warnedUnsafeIntegerColumns.has(warnKey)) {
+            warnedUnsafeIntegerColumns.add(warnKey);
+            console.warn(`SDA: Column ${(0, quoteIdentifier_js_1.default)(columnName)}${tableName === null ? "" : ` of table ${(0, quoteIdentifier_js_1.default)(tableName)}`} has at least one value exceeding Number.MAX_SAFE_INTEGER. Converted numbers may lose precision.`);
+        }
+        return Number(bigintValue);
+    };
+}
+function utcTimestampTzValue(value) {
+    if (value === null) {
+        return null;
+    }
+    const timestamp = new node_api_1.DuckDBTimestampValue(value.micros).toString();
+    return timestamp === "infinity" || timestamp === "-infinity"
+        ? timestamp
+        : `${timestamp}+00`;
+}
+const utcJsonValueConverter = (value, type, _converter) => type.typeId === node_api_1.DuckDBTypeId.TIMESTAMP_TZ
+    ? utcTimestampTzValue(value)
+    : (0, node_api_1.JsonDuckDBValueConverter)(value, type, utcJsonValueConverter);
+function makeConverter(type, columnName, tableName = null) {
+    const typeString = type.toString();
+    if (typeString.toLowerCase().includes("geometry")) {
+        const placeholder = `GEOM(${typeString.replace("GEOMETRY('", "").replace("')", "")})`;
+        return (value) => (value === null ? null : placeholder);
+    }
+    if (typeString.includes("FLOAT[")) {
+        const placeholder = `<${typeString}>`;
+        return (value) => (value === null ? null : placeholder);
+    }
+    switch (type.typeId) {
+        case node_api_1.DuckDBTypeId.DATE:
+            return (value) => value === null
+                ? null
+                : new Date(value.days * msPerDay);
+        case node_api_1.DuckDBTypeId.TIMESTAMP:
+            return (value) => {
+                if (value === null) {
+                    return null;
+                }
+                const micros = value.micros;
+                // Floor division, so sub-millisecond precision truncates toward
+                // the past for dates before the epoch too.
+                const ms = micros >= 0n ? micros / 1000n : (micros - 999n) / 1000n;
+                return new Date(Number(ms));
+            };
+        case node_api_1.DuckDBTypeId.TIMESTAMP_TZ:
+            return utcTimestampTzValue;
+        case node_api_1.DuckDBTypeId.BIGINT:
+        case node_api_1.DuckDBTypeId.HUGEINT:
+            return makeIntegerConverter(columnName, tableName);
+        default:
+            return (value) => utcJsonValueConverter(value, type, utcJsonValueConverter);
+    }
+}
+async function runQuery(query, connection, returnData, options) {
+    const values = options.values ?? [];
+    try {
+        await (0, observeQuery_js_1.default)(connection, query, values, options);
+        if (returnData) {
+            const result = values.length === 0
+                ? await connection.run(query)
+                : await connection.run(query, values);
+            const columnNames = result.deduplicatedColumnNames();
+            const columnTypes = result.columnTypes();
+            if (options.method === "getData()" &&
+                columnTypes.some((type) => type.toString().toLowerCase().includes("geometry"))) {
+                throw new Error("The query returns geometry columns. Use getGeoData() instead.");
+            }
+            const converters = columnTypes.map((type, i) => makeConverter(type, columnNames[i], options.table ?? null));
+            const columnCount = columnNames.length;
+            // The result is converted chunk by chunk, so no intermediate row-major
+            // copy of the whole result is materialized.
+            const rows = [];
+            while (true) {
+                const chunk = await result.fetchChunk();
+                if (chunk === null || chunk === undefined || chunk.rowCount === 0) {
+                    break;
+                }
+                const base = rows.length;
+                for (let i = 0; i < chunk.rowCount; i++) {
+                    rows.push({});
+                }
+                for (let j = 0; j < columnCount; j++) {
+                    const columnName = columnNames[j];
+                    const converter = converters[j];
+                    chunk.visitColumnValues(j, (value, rowIndex) => {
+                        rows[base + rowIndex][columnName] = converter(value);
+                    });
+                }
+            }
+            return rows;
+        }
+        else {
+            if (values.length === 0) {
+                await connection.run(query);
+            }
+            else {
+                await connection.run(query, values);
+            }
+            return null;
+        }
+    }
+    catch (error) {
+        throw new SDAError_js_1.default({
+            method: options.method,
+            parameters: options.parameters,
+            query,
+            cause: error,
+        });
+    }
+}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/serializeCacheInputs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts cache inputs to a deterministic, type-tagged representation.
+ * SimpleTable values are represented by their name and current generation.
+ */
+export default function serializeCacheInputs(inputs: readonly unknown[]): string;
+/** Returns a user-facing cache diagnostic label for supported input values. */
+export declare function getCacheInputLabel(value: unknown): string | undefined;
+//# sourceMappingURL=serializeCacheInputs.d.ts.map

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/serializeCacheInputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeCacheInputs.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/helpers/serializeCacheInputs.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,MAAM,CASR;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAIrE"}