@nshiab/simple-data-analysis 5.21.1 → 6.0.1

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

@@ -0,0 +1,122 @@
+import assertColumnsExist from "../helpers/assertColumnsExist.js";
+import getStatExpression, { allStats, } from "../helpers/getStatExpression.js";
+import keepNumericalColumns from "../helpers/keepNumericalColumns.js";
+import queueOp from "../helpers/queueOp.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import stringToArray from "../helpers/stringToArray.js";
+const allStatRowOperations = allStats.filter((stat) => stat !== "count");
+export default function addSummaryRows(simpleTable, columns, labelColumn, options = {}) {
+    options = structuredClone(options);
+    if (options.position !== undefined &&
+        options.position !== "top" &&
+        options.position !== "bottom") {
+        throw new Error(`addSummaryRows() options.position must be "top" or "bottom". Received ${JSON.stringify(options.position)}.`);
+    }
+    const selectedColumns = columns === "all" ? "all" : stringToArray(columns);
+    if (selectedColumns !== "all" && selectedColumns.length === 0) {
+        throw new Error('addSummaryRows() requires at least one column or "all".');
+    }
+    if (selectedColumns !== "all") {
+        const duplicates = selectedColumns.filter((column, index) => selectedColumns.indexOf(column) !== index);
+        if (duplicates.length > 0) {
+            throw new Error(`addSummaryRows() received duplicate column${new Set(duplicates).size === 1 ? "" : "s"} ${[...new Set(duplicates)].map(quoteIdentifier).join(", ")}.`);
+        }
+        if (selectedColumns.includes(labelColumn)) {
+            throw new Error(`addSummaryRows() label column ${quoteIdentifier(labelColumn)} cannot also be summarized.`);
+        }
+    }
+    const statRows = normalizeStatRows(options.stats);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "addSummaryRows()",
+        parameters: { columns, labelColumn, options },
+        needsSchema: true,
+        values: statRows.map((row) => row.label),
+        buildSelect: (input, schema) => addSummaryRowsSelect(input, schema, selectedColumns, labelColumn, statRows, options.position ?? "bottom"),
+    });
+}
+function normalizeStatRows(stats) {
+    const rows = stats === undefined
+        ? [...allStatRowOperations]
+        : Array.isArray(stats)
+            ? stats
+            : [stats];
+    if (rows.length === 0) {
+        throw new Error("addSummaryRows() stats cannot be an empty array. Omit stats to add every supported stat.");
+    }
+    return rows.map((row) => {
+        if (typeof row === "string") {
+            assertStat(row);
+            return { stat: row, label: row };
+        }
+        if (row === null || typeof row !== "object") {
+            throw new Error("addSummaryRows() stats must contain stat names or objects with a stat property.");
+        }
+        assertStat(row.stat);
+        if (row.label !== undefined && typeof row.label !== "string") {
+            throw new Error("addSummaryRows() stat labels must be strings.");
+        }
+        return { stat: row.stat, label: row.label ?? row.stat };
+    });
+}
+function assertStat(stat) {
+    if (!allStatRowOperations.includes(stat)) {
+        throw new Error(`addSummaryRows() stat ${JSON.stringify(stat)} is not supported. Use ${allStatRowOperations.map((value) => JSON.stringify(value)).join(", ")}.`);
+    }
+}
+function addSummaryRowsSelect(input, schema, columns, labelColumn, statRows, position) {
+    const method = "addSummaryRows()";
+    const tableColumns = Object.keys(schema);
+    assertColumnsExist(schema, [labelColumn], method);
+    if (schema[labelColumn] !== "VARCHAR") {
+        throw new Error(`${method} label column ${quoteIdentifier(labelColumn)} must have type VARCHAR, but has type ${schema[labelColumn]}.`);
+    }
+    const numericalColumns = keepNumericalColumns(schema);
+    const selectedColumns = columns === "all" ? numericalColumns : columns;
+    if (selectedColumns.length === 0) {
+        throw new Error(`${method} could not find any numeric columns. Select numeric columns explicitly or convert columns to numeric types first.`);
+    }
+    if (columns !== "all") {
+        assertColumnsExist(schema, selectedColumns, method);
+        const numericalColumnSet = new Set(numericalColumns);
+        const nonNumericalColumns = selectedColumns.filter((column) => !numericalColumnSet.has(column));
+        if (nonNumericalColumns.length > 0) {
+            throw new Error(`${method} requires numeric columns, but ${nonNumericalColumns.map((column) => `${quoteIdentifier(column)} has type ${schema[column]}`).join(", ")}. Convert ${nonNumericalColumns.length === 1 ? "it" : "them"} to a numeric type first.`);
+        }
+    }
+    const selectedColumnSet = new Set(selectedColumns);
+    const kindColumn = unusedColumn(schema, "_sda_stat_kind");
+    const orderColumn = unusedColumn({ ...schema, [kindColumn]: "INTEGER" }, "_sda_stat_order");
+    const projectedColumns = tableColumns.map(quoteIdentifier).join(", ");
+    const dataKind = position === "top" ? 1 : 0;
+    const statKind = position === "top" ? 0 : 1;
+    const branches = [
+        `SELECT ${projectedColumns}, ${dataKind} AS ${quoteIdentifier(kindColumn)}, ROW_NUMBER() OVER () AS ${quoteIdentifier(orderColumn)} FROM ${input}`,
+        ...statRows.map((row, index) => {
+            const projections = tableColumns.map((column) => {
+                if (column === labelColumn) {
+                    return `CAST(? AS VARCHAR) AS ${quoteIdentifier(column)}`;
+                }
+                if (!selectedColumnSet.has(column)) {
+                    return `NULL AS ${quoteIdentifier(column)}`;
+                }
+                const expression = getStatExpression(row.stat, schema[column], quoteIdentifier(column), undefined);
+                if (expression === null) {
+                    throw new Error(`${method} stat ${JSON.stringify(row.stat)} cannot be computed for column ${quoteIdentifier(column)} with type ${schema[column]}.`);
+                }
+                return `${expression} AS ${quoteIdentifier(column)}`;
+            });
+            return `SELECT ${projections.join(", ")}, ${statKind} AS ${quoteIdentifier(kindColumn)}, ${index} AS ${quoteIdentifier(orderColumn)} FROM ${input}`;
+        }),
+    ];
+    return `SELECT ${projectedColumns}
+FROM (${branches.join("\nUNION ALL\n")}) AS ${quoteIdentifier("stats")}
+ORDER BY ${quoteIdentifier(kindColumn)}, ${quoteIdentifier(orderColumn)}`;
+}
+function unusedColumn(schema, base) {
+    let column = base;
+    while (schema[column] !== undefined) {
+        column += "_";
+    }
+    return column;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"addVertexCount.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/addVertexCount.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/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/addVertexCount.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 addVertexCount(simpleTable, newColumn, options = {}) {
+    options = { ...options };
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "addVertexCount()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "addVertexCount()");
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "addVertexCount()", simpleTable.name);
+            return `SELECT *, CAST(ST_NPoints(${quoteIdentifier(column)}) AS BIGINT) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function aggregateGeo(simpleTable: SimpleTable, method: "union" | "intersection", options?: {
+    column?: string;
+    by?: string | string[];
+    outputTable?: string | boolean;
+}): SimpleTable;
+//# sourceMappingURL=aggregateGeo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateGeo.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/aggregateGeo.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,OAAO,GAAG,cAAc,EAChC,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAmDb"}

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

@@ -0,0 +1,69 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumn from "../helpers/findGeoColumn.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
+import stringToArray from "../helpers/stringToArray.js";
+export default function aggregateGeo(simpleTable, method, options = {}) {
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    if (typeof options.outputTable === "string") {
+        // The output table instance is created at call time so it can be
+        // returned synchronously and chained on right away.
+        const outputTable = simpleTable.sdb.newTable(options.outputTable);
+        queueOp(outputTable, {
+            kind: "barrier",
+            method: "aggregateGeo()",
+            parameters: { method, options },
+            execute: async () => {
+                const column = typeof options.column === "string"
+                    ? options.column
+                    : await findGeoColumn(simpleTable, "aggregateGeo()");
+                await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS ${aggregateGeoSelect(`${quoteIdentifier(simpleTable.name)}`, column, method, options)}`, mergeOptions(simpleTable, {
+                    table: outputTable.name,
+                    method: "aggregateGeo()",
+                    parameters: { column, method, options },
+                }));
+            },
+        });
+        return outputTable;
+    }
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "aggregateGeo()",
+        parameters: { method, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "aggregateGeo()", simpleTable.name);
+            return aggregateGeoSelect(input, column, method, options);
+        },
+    });
+    return simpleTable;
+}
+function aggregateGeoSelect(input, column, method, options = {}) {
+    const categoriesOptions = options.by ?? [];
+    const by = stringToArray(categoriesOptions);
+    let query = `SELECT${by.length > 0
+        ? ` ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")},`
+        : ""}`;
+    if (method === "union") {
+        query += ` CASE WHEN ST_IsEmpty(ST_Union_Agg(${quoteIdentifier(column)})) THEN NULL ELSE ST_Union_Agg(${quoteIdentifier(column)}) END AS ${quoteIdentifier(column)}`;
+    }
+    else if (method === "intersection") {
+        query += ` ST_Intersection_Agg(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)}`;
+    }
+    else {
+        throw new Error(`aggregateGeo() received an unknown method: ${method}.`);
+    }
+    query += `\nFROM ${input}`;
+    if (by.length > 0) {
+        query += `\nGROUP BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")}`;
+        query += `\nORDER BY ${by.map((d) => `${quoteIdentifier(d)} ASC`).join(", ")}`;
+    }
+    return query;
+}

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

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

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

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

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

@@ -0,0 +1,25 @@
+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 area(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "area()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "area()");
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "area()", simpleTable.name);
+            let expression = `ST_Area_Spheroid(${quoteIdentifier(column)}) ${options.unit === "km2" ? "/ 1000000" : ""}`;
+            if (typeof options.decimals === "number") {
+                expression = `ROUND(${expression}, ${options.decimals})`;
+            }
+            return `SELECT *, CAST(${expression} AS DOUBLE) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"bins.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/bins.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,QAiCP"}

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

@@ -0,0 +1,87 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+export default 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);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "bins()",
+        parameters: { column, interval, newColumn, options },
+        execute: async () => {
+            await queryDB(simpleTable, await binsQuery(simpleTable, column, interval, newColumn, options), mergeOptions(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.
+    assertNewColumns(await SimpleTable.getTypes(), [newColumn], "bins()");
+    // The minimum and maximum are computed in one scan instead of one
+    // getMin/getMax query each.
+    const minMax = await queryDB(SimpleTable, `SELECT MIN(${quoteIdentifier(column)}) AS "min", MAX(${quoteIdentifier(column)}) AS "max" FROM ${quoteIdentifier(SimpleTable.name)}`, mergeOptions(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 ${quoteIdentifier(column)} >= ${start} AND ${quoteIdentifier(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 ${quoteIdentifier(SimpleTable.name)} AS
+    SELECT *, CASE
+    ${intervals.join("\n")}
+    END AS ${quoteIdentifier(newColumn)}
+    FROM ${quoteIdentifier(SimpleTable.name)}`;
+    return query;
+}

package/esm/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/esm/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/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/bm25.js

@@ -0,0 +1,63 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import camelCase from "../helpers/camelCase.js";
+import queryDB from "../helpers/queryDB.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queueOp from "../helpers/queueOp.js";
+import { executeCreateFtsIndex } from "./createFtsIndex.js";
+export default 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;
+    queueOp(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 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 ${quoteIdentifier(options.scoreColumn)}`
+        : `* EXCLUDE(score)`;
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS SELECT ${selectClause} FROM (SELECT *, ${quoteIdentifier(`fts_main_${camelCase(simpleTable.name)}`)}.match_bm25(${quoteIdentifier(idColumn)}, ?${typeof options.k === "number" ? `, k := ${options.k}` : ""}${typeof options.b === "number" ? `, b := ${options.b}` : ""}${options.conjunctive === true ? `, conjunctive := 1` : ""}) AS score FROM ${quoteIdentifier(simpleTable.name)}) sq WHERE score NOT NULL${minScoreCondition} ORDER BY score DESC LIMIT ${count};`, mergeOptions(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/esm/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/esm/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/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/buffer.js

@@ -0,0 +1,24 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function buffer(simpleTable, newColumn, distance, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "buffer()",
+        parameters: { newColumn, distance, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(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(${quoteIdentifier(column)}, ${distance})::${types[column]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/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/esm/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"}