@nshiab/simple-data-analysis 5.21.0 → 6.0.0

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

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = bins;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const assertNewColumns_js_1 = __importDefault(require("../helpers/assertNewColumns.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function bins(simpleTable, column, interval, newColumn, options = {}) {
+    // This validation does not need the database, so it stays at call time.
+    if (!Number.isFinite(interval) || interval <= 0) {
+        throw new Error("bins() interval must be a finite number greater than 0.");
+    }
+    // The intervals depend on the minimum and maximum values of the data, so
+    // bins can't be expressed as a single SELECT over its input: it executes
+    // as a barrier.
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "barrier",
+        method: "bins()",
+        parameters: { column, interval, newColumn, options },
+        execute: async () => {
+            await (0, queryDB_js_1.default)(simpleTable, await binsQuery(simpleTable, column, interval, newColumn, options), (0, mergeOptions_js_1.default)(simpleTable, {
+                table: simpleTable.name,
+                method: "bins()",
+                parameters: {
+                    column,
+                    interval,
+                    newColumn,
+                    options,
+                },
+            }));
+        },
+    });
+}
+async function binsQuery(SimpleTable, column, interval, newColumn, options = {}) {
+    // A SELECT *, expr AS col colliding with an existing column would be
+    // silently renamed by DuckDB (col -> col_1) instead of erroring, unlike
+    // the ALTER TABLE ADD this used to run.
+    (0, assertNewColumns_js_1.default)(await SimpleTable.getTypes(), [newColumn], "bins()");
+    // The minimum and maximum are computed in one scan instead of one
+    // getMin/getMax query each.
+    const minMax = await (0, queryDB_js_1.default)(SimpleTable, `SELECT MIN(${(0, quoteIdentifier_js_1.default)(column)}) AS "min", MAX(${(0, quoteIdentifier_js_1.default)(column)}) AS "max" FROM ${(0, quoteIdentifier_js_1.default)(SimpleTable.name)}`, (0, mergeOptions_js_1.default)(SimpleTable, {
+        table: SimpleTable.name,
+        method: "bins()",
+        parameters: { column, interval, newColumn, options },
+        returnData: true,
+    }));
+    const minValue = minMax?.[0]?.min;
+    if (typeof minValue !== "number") {
+        throw new Error(`minValue of ${column} is not a number`);
+    }
+    let startValue;
+    if (typeof options.startValue === "number") {
+        if (options.startValue > minValue) {
+            throw new Error(`startValue ${options.startValue} can't be greater than minValue ${minValue}`);
+        }
+        startValue = options.startValue;
+    }
+    else {
+        startValue = minValue;
+    }
+    const maxValue = minMax?.[0]?.max;
+    if (typeof maxValue !== "number") {
+        throw new Error(`maxValue of ${column} is not a number`);
+    }
+    const endValue = maxValue;
+    let increment = 1;
+    let decimals = 0;
+    const intervalAsString = interval.toString();
+    const decimalIndex = intervalAsString.indexOf(".");
+    if (decimalIndex > 0) {
+        decimals = intervalAsString.substring(decimalIndex + 1).length;
+        increment = 1.0 / (10.0 * decimals);
+    }
+    const intervals = [];
+    for (let i = startValue; i <= endValue; i += interval) {
+        const start = i;
+        const end = (i + interval - increment).toFixed(decimals);
+        intervals.push(`WHEN ${(0, quoteIdentifier_js_1.default)(column)} >= ${start} AND ${(0, quoteIdentifier_js_1.default)(column)} <= ${end} THEN '[${start}-${end}]'`);
+    }
+    // A single rewrite, so the table is scanned once instead of once for the
+    // ALTER and once for the UPDATE.
+    const query = `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(SimpleTable.name)} AS
+    SELECT *, CASE
+    ${intervals.join("\n")}
+    END AS ${(0, quoteIdentifier_js_1.default)(newColumn)}
+    FROM ${(0, quoteIdentifier_js_1.default)(SimpleTable.name)}`;
+    return query;
+}

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

@@ -0,0 +1,17 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function bm25(simpleTable: SimpleTable, text: string, idColumn: string, textColumn: string, count: number, options?: {
+    stemmer?: "arabic" | "basque" | "catalan" | "danish" | "dutch" | "english" | "finnish" | "french" | "german" | "greek" | "hindi" | "hungarian" | "indonesian" | "irish" | "italian" | "lithuanian" | "nepali" | "norwegian" | "porter" | "portuguese" | "romanian" | "russian" | "serbian" | "spanish" | "swedish" | "tamil" | "turkish" | "none";
+    stopwords?: string;
+    ignore?: string;
+    stripAccents?: boolean;
+    lower?: boolean;
+    k?: number;
+    b?: number;
+    minScore?: number;
+    scoreColumn?: string;
+    overwriteIndex?: boolean;
+    conjunctive?: boolean;
+    outputTable?: string;
+    verbose?: boolean;
+}): SimpleTable;
+//# sourceMappingURL=bm25.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bm25.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/bm25.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,OAAO,CAAC,EACJ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,WAAW,CA4Bb"}

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

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = bm25;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const camelCase_js_1 = __importDefault(require("../helpers/camelCase.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const createFtsIndex_js_1 = require("./createFtsIndex.js");
+function bm25(simpleTable, text, idColumn, textColumn, count, options = {}) {
+    options = structuredClone(options);
+    // This uses the fts extension
+    // https://duckdb.org/docs/stable/core_extensions/full_text_search
+    // The output table instance is created at call time so it can be returned
+    // synchronously and chained on right away.
+    const outputTable = typeof options.outputTable === "string"
+        ? simpleTable.sdb.newTable(options.outputTable)
+        : simpleTable;
+    (0, queueOp_js_1.default)(outputTable, {
+        kind: "barrier",
+        method: "bm25()",
+        parameters: { text, idColumn, textColumn, count, options },
+        execute: () => executeBm25(simpleTable, outputTable, text, idColumn, textColumn, count, options),
+    });
+    return outputTable;
+}
+async function executeBm25(simpleTable, outputTable, text, idColumn, textColumn, count, options) {
+    // The index creation runs directly (not with the sync createFtsIndex
+    // builder, which would queue for the next flush).
+    await (0, createFtsIndex_js_1.executeCreateFtsIndex)(simpleTable, idColumn, textColumn, {
+        stemmer: options.stemmer,
+        stopwords: options.stopwords,
+        ignore: options.ignore,
+        stripAccents: options.stripAccents,
+        lower: options.lower,
+        overwrite: options.overwriteIndex,
+        verbose: options.verbose,
+    });
+    const minScoreCondition = typeof options.minScore === "number"
+        ? ` AND score >= ${options.minScore}`
+        : "";
+    const selectClause = typeof options.scoreColumn === "string"
+        ? `* EXCLUDE(score), score AS ${(0, quoteIdentifier_js_1.default)(options.scoreColumn)}`
+        : `* EXCLUDE(score)`;
+    await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(outputTable.name)} AS SELECT ${selectClause} FROM (SELECT *, ${(0, quoteIdentifier_js_1.default)(`fts_main_${(0, camelCase_js_1.default)(simpleTable.name)}`)}.match_bm25(${(0, quoteIdentifier_js_1.default)(idColumn)}, ?${typeof options.k === "number" ? `, k := ${options.k}` : ""}${typeof options.b === "number" ? `, b := ${options.b}` : ""}${options.conjunctive === true ? `, conjunctive := 1` : ""}) AS score FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}) sq WHERE score NOT NULL${minScoreCondition} ORDER BY score DESC LIMIT ${count};`, (0, mergeOptions_js_1.default)(simpleTable, {
+        table: simpleTable.name,
+        method: "bm25",
+        parameters: {
+            text,
+            idColumn,
+            textColumn,
+            count,
+            minScore: options.minScore,
+            scoreColumn: options.scoreColumn,
+            k: options.k,
+            b: options.b,
+            stemmer: options.stemmer,
+            stopwords: options.stopwords,
+            ignore: options.ignore,
+            stripAccents: options.stripAccents,
+            lower: options.lower,
+            table: options.outputTable ?? simpleTable.name,
+        },
+        values: [text],
+    }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/buffer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,QA2BlC"}

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

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buffer;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const findGeoColumnFromSchema_js_1 = __importDefault(require("../helpers/findGeoColumnFromSchema.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function buffer(simpleTable, newColumn, distance, options = {}) {
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "buffer()",
+        parameters: { newColumn, distance, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const column = typeof options.column === "string"
+                ? options.column
+                : (0, findGeoColumnFromSchema_js_1.default)(types, "buffer()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Buffer(${(0, quoteIdentifier_js_1.default)(column)}, ${distance})::${types[column]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function cache<Table extends SimpleTable>(table: Table, compute: (table: Table) => void | Promise<void>, options?: {
+    ttl?: number;
+    inputs?: readonly unknown[];
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/cache.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AA2DvD,wBAA8B,KAAK,CAAC,KAAK,SAAS,WAAW,EAC3D,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBAwLP"}

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

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cache;
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const flushAllTables_js_1 = __importDefault(require("../helpers/flushAllTables.js"));
+const prettyDuration_js_1 = __importDefault(require("../helpers/prettyDuration.js"));
+const cacheDiagnostics_js_1 = require("../helpers/cacheDiagnostics.js");
+const serializeCacheInputs_js_1 = __importStar(require("../helpers/serializeCacheInputs.js"));
+const tableGeneration_js_1 = require("../helpers/tableGeneration.js");
+const cacheDatabase_js_1 = require("../helpers/cacheDatabase.js");
+const cacheTableDependencies_js_1 = require("../helpers/cacheTableDependencies.js");
+const CACHE_FORMAT_VERSION = "duckdb-v4";
+async function cache(table, compute, options = {}) {
+    // If cache() is itself called from another cache computation, the outer
+    // computation depends on the table produced here.
+    (0, cacheTableDependencies_js_1.recordCacheTableAccess)(table);
+    options.verbose &&
+        console.log(`\ncache() for ${table.name}`);
+    // cache() is an observation point even when a cache hit has no artifact to
+    // load, so all earlier database-wide work must complete before it returns.
+    await (0, flushAllTables_js_1.default)(table.sdb);
+    const cachePath = "./.sda-cache";
+    if (!(0, node_fs_1.existsSync)(cachePath)) {
+        (0, node_fs_1.mkdirSync)(cachePath);
+    }
+    const cacheSourcesPath = `${cachePath}/sources.json`;
+    let cacheSources = {};
+    if ((0, node_fs_1.existsSync)(cacheSourcesPath)) {
+        cacheSources = JSON.parse((0, node_fs_1.readFileSync)(cacheSourcesPath, "utf-8"));
+    }
+    const functionBody = compute.toString();
+    const entryGeneration = (0, tableGeneration_js_1.peekTableGeneration)(table) ?? null;
+    const inputs = options.inputs?.filter((input) => input !== table) ?? [];
+    const hasInputs = inputs.length > 0;
+    const serializedInputs = hasInputs ? (0, serializeCacheInputs_js_1.default)(inputs) : null;
+    const codeHash = createHash(functionBody);
+    const inputHashes = hasInputs
+        ? inputs.map((input) => createHash((0, serializeCacheInputs_js_1.default)([input])))
+        : [];
+    const hash = createHash(JSON.stringify([
+        CACHE_FORMAT_VERSION,
+        table.name,
+        entryGeneration,
+        functionBody,
+        serializedInputs,
+    ]));
+    const requestedId = `${table.name}.${hash}`;
+    let id = requestedId;
+    let cache = cacheSources[id];
+    if (cache === undefined) {
+        const alreadyApplied = findAlreadyAppliedCache(table, cacheSources, entryGeneration, codeHash, inputHashes);
+        if (alreadyApplied !== undefined) {
+            [id, cache] = alreadyApplied;
+        }
+    }
+    if (cache !== undefined &&
+        !(0, cacheTableDependencies_js_1.cacheTableDependenciesMatch)(table, cache.tableDependencies)) {
+        cache = undefined;
+    }
+    const now = Date.now();
+    if (cache !== undefined) {
+        ensureCacheDiagnostics(cache, cacheSources, cacheSourcesPath, codeHash, inputHashes);
+    }
+    if (cache === undefined) {
+        if (options.verbose) {
+            logCacheMiss(table, cacheSources, codeHash, inputHashes, inputs, entryGeneration);
+        }
+        await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, id, codeHash, inputHashes, entryGeneration);
+    }
+    else if (options.ttl !== undefined &&
+        (0, cacheDiagnostics_js_1.cacheEntryExpired)(cache.creation, options.ttl, now)) {
+        const refreshId = cache.entryGeneration === entryGeneration
+            ? id
+            : requestedId;
+        options.verbose &&
+            console.log(`Cache entry is stale.\n${identityMatchMessage(inputHashes, cache.tableDependencies ?? [])}\n${(0, cacheDiagnostics_js_1.cacheTtlMessage)(cache.creation, options.ttl, now, true)}\nRunning computations and refreshing the cache entry.`);
+        await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, refreshId, codeHash, inputHashes, entryGeneration);
+    }
+    else {
+        options.verbose &&
+            console.log(`Cache hit.\n${identityMatchMessage(inputHashes, cache.tableDependencies ?? [])}`);
+        if (typeof options.ttl === "number") {
+            (options.verbose) &&
+                console.log((0, cacheDiagnostics_js_1.cacheTtlMessage)(cache.creation, options.ttl, now, false));
+        }
+        if (cache.file === null) {
+            console.log("No data in cache. Nothing to load.");
+        }
+        else {
+            const start = Date.now();
+            try {
+                await (0, cacheDatabase_js_1.loadCacheDatabase)(table, cache.file, cache.indexes ?? [], cache.geo);
+            }
+            catch {
+                options.verbose &&
+                    console.log("Could not load cached data. Recomputing...");
+                if ((0, node_fs_1.existsSync)(cache.file)) {
+                    (0, node_fs_1.rmSync)(cache.file);
+                }
+                delete cacheSources[id];
+                await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, requestedId, codeHash, inputHashes, entryGeneration);
+                return;
+            }
+            if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
+                table.sdb.cacheSourcesUsed.push(id);
+            }
+            const end = Date.now();
+            const duration = end - start;
+            if (options.verbose) {
+                console.log(`${(0, cacheDiagnostics_js_1.cacheLoadMessage)(start, end, cache.duration)}\n`);
+                table.sdb.cacheTimeSaved += cache.duration - duration;
+            }
+        }
+        restoreCachedGeneration(table, cache, cacheSources, cacheSourcesPath);
+    }
+}
+async function runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, id, codeHash, inputHashes, entryGeneration) {
+    // Complete any work queued before cache() before dependency observation
+    // begins. Operations queued by compute are flushed inside the observation.
+    await (0, flushAllTables_js_1.default)(table.sdb);
+    const start = Date.now();
+    const tableDependencies = await (0, cacheTableDependencies_js_1.captureCacheTableDependencies)(table, async () => {
+        await compute(table);
+        // run() only queues the sync builders in the user's callback; the actual
+        // computation happens at the flush, so it must be included in the timing
+        // that decides how much the cache saves on later hits.
+        await (0, flushAllTables_js_1.default)(table.sdb);
+    });
+    const end = Date.now();
+    const duration = end - start;
+    const generationId = (0, tableGeneration_js_1.createTableGenerationId)();
+    table.sdb.cacheVerbose &&
+        console.log(`Computations done in ${(0, prettyDuration_js_1.default)(start, { end })}.`);
+    if (!(await table.sdb.hasTable(table.name))) {
+        console.log(`No data in table ${table.name}. Nothing stored in cache.`);
+        cacheSources[id] = {
+            creation: Date.now(),
+            duration,
+            file: null,
+            geo: false,
+            entryGeneration,
+            generationId,
+            indexes: [],
+            formatVersion: CACHE_FORMAT_VERSION,
+            codeHash,
+            inputHashes,
+            tableDependencies,
+        };
+    }
+    else {
+        const types = await table.getTypes();
+        const geometriesColumns = Object.values(types).filter((d) => d.toLowerCase().includes("geometry")).length;
+        const file = `${cachePath}/${id}.db`;
+        const indexes = structuredClone(table.indexes);
+        const writeStart = Date.now();
+        await (0, cacheDatabase_js_1.writeCacheDatabase)(table, file, indexes);
+        const writeEnd = Date.now();
+        table.sdb.cacheVerbose &&
+            console.log(`Wrote in cache in ${(0, prettyDuration_js_1.default)(writeStart, { end: writeEnd })}.\n`);
+        table.sdb.cacheTimeWriting += writeEnd - writeStart;
+        cacheSources[id] = {
+            creation: Date.now(),
+            duration,
+            file,
+            geo: geometriesColumns > 0,
+            entryGeneration,
+            generationId,
+            indexes,
+            formatVersion: CACHE_FORMAT_VERSION,
+            codeHash,
+            inputHashes,
+            tableDependencies,
+        };
+        if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
+            table.sdb.cacheSourcesUsed.push(id);
+        }
+    }
+    (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    (0, tableGeneration_js_1.restoreTableGeneration)(table, generationId);
+}
+function restoreCachedGeneration(table, cache, cacheSources, cacheSourcesPath) {
+    if (cache.generationId === undefined) {
+        cache.generationId = (0, tableGeneration_js_1.createTableGenerationId)();
+        (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    }
+    (0, tableGeneration_js_1.restoreTableGeneration)(table, cache.generationId);
+}
+function ensureCacheDiagnostics(cache, cacheSources, cacheSourcesPath, codeHash, inputHashes) {
+    if (cache.formatVersion === undefined || cache.codeHash === undefined ||
+        cache.inputHashes === undefined) {
+        cache.formatVersion = CACHE_FORMAT_VERSION;
+        cache.codeHash = codeHash;
+        cache.inputHashes = inputHashes;
+        (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    }
+}
+function createHash(value) {
+    return node_crypto_1.default.createHash("sha256").update(value).digest("hex");
+}
+function identityMatchMessage(inputHashes, tableDependencies) {
+    const inputsMessage = inputHashes.length === 0
+        ? "Compute function unchanged."
+        : `Compute function unchanged.\nInputs unchanged (${inputHashes.length} checked).`;
+    const dependenciesMessage = tableDependencies.length === 0
+        ? ""
+        : `\n${(0, cacheTableDependencies_js_1.unchangedCacheTableDependenciesMessage)(tableDependencies)}`;
+    return `${inputsMessage}${dependenciesMessage}`;
+}
+function findAlreadyAppliedCache(table, cacheSources, entryGeneration, codeHash, inputHashes) {
+    if (entryGeneration === null) {
+        return undefined;
+    }
+    return Object.entries(cacheSources)
+        .filter(([id, source]) => id.startsWith(`${table.name}.`) &&
+        source.formatVersion === CACHE_FORMAT_VERSION &&
+        source.generationId === entryGeneration &&
+        source.codeHash === codeHash &&
+        arraysEqual(source.inputHashes, inputHashes) &&
+        (0, cacheTableDependencies_js_1.cacheTableDependenciesMatch)(table, source.tableDependencies))
+        .reduce((latest, candidate) => latest === undefined || candidate[1].creation > latest[1].creation
+        ? candidate
+        : latest, undefined);
+}
+function arraysEqual(left, right) {
+    return left !== undefined && left.length === right.length &&
+        left.every((value, index) => value === right[index]);
+}
+function logCacheMiss(table, cacheSources, codeHash, inputHashes, inputs, entryGeneration) {
+    const candidates = Object.entries(cacheSources)
+        .filter(([id]) => id.startsWith(`${table.name}.`))
+        .map(([, source]) => source)
+        .filter(isCacheDiagnosticSource);
+    let reason;
+    if (candidates.length === 0) {
+        const hasLegacyCandidate = Object.keys(cacheSources).some((id) => id.startsWith(`${table.name}.`));
+        reason = hasLegacyCandidate
+            ? "A previous entry exists, but it predates detailed cache diagnostics. Its code, inputs, or cache format changed."
+            : "No matching cache entry exists for this computation.";
+    }
+    else {
+        const sameFormat = candidates.filter((source) => source.formatVersion === CACHE_FORMAT_VERSION);
+        const sameCode = latestCacheSource(sameFormat.filter((source) => source.codeHash === codeHash));
+        if (sameCode !== undefined) {
+            const inputsMessage = changedInputsMessage(sameCode.inputHashes, inputHashes, inputs);
+            const tableMessage = sameCode.entryGeneration === entryGeneration
+                ? ""
+                : "The current table has changed.";
+            const dependenciesMessage = (0, cacheTableDependencies_js_1.changedCacheTableDependenciesMessage)(table, sameCode.tableDependencies);
+            const changes = [tableMessage, inputsMessage, dependenciesMessage]
+                .filter((message) => message.length > 0);
+            reason = changes.length === 0
+                ? "Compute function unchanged."
+                : `Compute function unchanged.\n${changes.join("\n")}`;
+        }
+        else if (sameFormat.length === 0) {
+            reason = "The cache format changed.";
+        }
+        else {
+            reason = "No matching cache entry exists for this computation.";
+        }
+    }
+    console.log(`Cache miss.\n${reason}\nRunning computations and storing a new cache entry.`);
+}
+function latestCacheSource(cacheSources) {
+    return cacheSources.reduce((latest, source) => latest === undefined || source.creation > latest.creation
+        ? source
+        : latest, undefined);
+}
+function isCacheDiagnosticSource(source) {
+    return source.formatVersion !== undefined && source.codeHash !== undefined &&
+        source.inputHashes !== undefined && source.tableDependencies !== undefined;
+}
+function changedInputsMessage(previousHashes, inputHashes, inputs) {
+    const changes = [];
+    const sharedLength = Math.min(previousHashes.length, inputHashes.length);
+    for (let i = 0; i < sharedLength; i++) {
+        if (previousHashes[i] !== inputHashes[i]) {
+            changes.push(`${(0, serializeCacheInputs_js_1.getCacheInputLabel)(inputs[i]) ?? `inputs[${i}]`} changed`);
+        }
+    }
+    for (let i = sharedLength; i < inputHashes.length; i++) {
+        changes.push(`${(0, serializeCacheInputs_js_1.getCacheInputLabel)(inputs[i]) ?? `inputs[${i}]`} was added`);
+    }
+    for (let i = sharedLength; i < previousHashes.length; i++) {
+        changes.push(`inputs[${i}] was removed`);
+    }
+    return changes.length === 0
+        ? inputHashes.length === 0
+            ? ""
+            : `Inputs unchanged (${inputHashes.length} checked).`
+        : `Inputs changed: ${changes.join(", ")}.`;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/capitalize.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,QAmB3B"}

package/script/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/capitalize.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 = capitalize;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function capitalize(simpleTable, columns) {
+    const cols = (0, stringToArray_js_1.default)(columns);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "capitalize()",
+        parameters: { columns },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (${cols
+            .map((c) => `CONCAT(UPPER(LEFT(${(0, quoteIdentifier_js_1.default)(c)}, 1)), LOWER(RIGHT(${(0, quoteIdentifier_js_1.default)(c)}, LENGTH(${(0, quoteIdentifier_js_1.default)(c)})-1))) AS ${(0, quoteIdentifier_js_1.default)(c)}`)
+            .join(", ")}) FROM ${input}`,
+    });
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"centroid.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/centroid.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,QA2BlC"}

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

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = centroid;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const findGeoColumnFromSchema_js_1 = __importDefault(require("../helpers/findGeoColumnFromSchema.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function centroid(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "centroid()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const column = typeof options.column === "string"
+                ? options.column
+                : (0, findGeoColumnFromSchema_js_1.default)(types, "centroid()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Centroid(${(0, quoteIdentifier_js_1.default)(column)})::${types[column]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function clone(simpleTable: SimpleTable, nameOrOptions?: string | {
+    name?: string;
+    conditions?: string;
+    columns?: string | string[];
+    limit?: number;
+    offset?: number;
+}): SimpleTable;
+//# sourceMappingURL=clone.d.ts.map