@nshiab/simple-data-analysis-core 0.0.12

package/esm/helpers/runQuery.d.ts

@@ -0,0 +1,14 @@
+import type { DuckDBConnection } from "@duckdb/node-api";
+export default function runQuery(query: string, connection: DuckDBConnection, returnDataFromQuery: boolean, options: {
+    debug: boolean;
+    method: string | null;
+    parameters: {
+        [key: string]: unknown;
+    } | null;
+    types?: {
+        [key: string]: string;
+    };
+}): Promise<{
+    [key: string]: number | string | Date | boolean | null;
+}[] | null>;
+//# sourceMappingURL=runQuery.d.ts.map

package/esm/helpers/runQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/runQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,wBAA8B,QAAQ,CACpC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,gBAAgB,EAC5B,mBAAmB,EAAE,OAAO,EAC5B,OAAO,EAAE;IACP,KAAK,EAAE,OAAO,CAAC;IACf,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;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACnC,GACA,OAAO,CACN;IACA,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC;CACxD,EAAE,GACD,IAAI,CACP,CA4BA"}

package/esm/helpers/runQuery.js

@@ -0,0 +1,26 @@
+import convertForJS from "./convertForJS.js";
+export default async function runQuery(query, connection, returnDataFromQuery, options) {
+    try {
+        if (returnDataFromQuery) {
+            const reader = await connection.runAndReadAll(query);
+            const rows = reader.getRowObjectsJson();
+            if (options.types) {
+                convertForJS(rows, options.types);
+            }
+            return rows;
+        }
+        else {
+            await connection.run(query);
+            return null;
+        }
+    }
+    catch (error) {
+        console.warn(error);
+        if (options.debug === false) {
+            console.log("SDA: method causing error =>", options.method);
+            console.log("parameters:", options.parameters);
+            console.log("query:", query);
+        }
+        throw error;
+    }
+}

package/esm/helpers/setDbProps.d.ts

@@ -0,0 +1,3 @@
+import type SimpleDB from "../class/SimpleDB.js";
+export default function setDbProps(simpleDB: SimpleDB, file: string, extension: string, allIndexesFile: string): Promise<void>;
+//# sourceMappingURL=setDbProps.d.ts.map

package/esm/helpers/setDbProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setDbProps.d.ts","sourceRoot":"","sources":["../../src/helpers/setDbProps.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAEjD,wBAA8B,UAAU,CACtC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,iBA8BvB"}

package/esm/helpers/setDbProps.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from "node:fs";
+export default async function setDbProps(simpleDB, file, extension, allIndexesFile) {
+    for (const table of await simpleDB.getTableNames()) {
+        simpleDB.newTable(table);
+    }
+    const allProjectionsFile = `${file.replace(`.${extension}`, "")}_projections.json`;
+    if (existsSync(allProjectionsFile)) {
+        const projections = JSON.parse(readFileSync(allProjectionsFile, "utf-8"));
+        for (const table of simpleDB.tables) {
+            if (projections[table.name]) {
+                table.projections = projections[table.name];
+            }
+        }
+        await simpleDB.customQuery(`INSTALL spatial; LOAD spatial;`);
+    }
+    if (existsSync(allIndexesFile)) {
+        const indexes = JSON.parse(readFileSync(allIndexesFile, "utf-8"));
+        for (const table of simpleDB.tables) {
+            if (indexes[table.name]) {
+                table.indexes = indexes[table.name];
+            }
+        }
+    }
+    simpleDB.tableIncrement = Math.round(Math.random() * 1000000);
+}

package/esm/helpers/shouldFlipBeforeExport.d.ts

@@ -0,0 +1,2 @@
+export default function shouldFlipBeforeExport(projection: string): boolean;
+//# sourceMappingURL=shouldFlipBeforeExport.d.ts.map

package/esm/helpers/shouldFlipBeforeExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldFlipBeforeExport.d.ts","sourceRoot":"","sources":["../../src/helpers/shouldFlipBeforeExport.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,UAAU,EAAE,MAAM,WAEhE"}

package/esm/helpers/shouldFlipBeforeExport.js

@@ -0,0 +1,3 @@
+export default function shouldFlipBeforeExport(projection) {
+    return projection.includes("proj=latlong");
+}

package/esm/helpers/stringToArray.d.ts

@@ -0,0 +1,2 @@
+export default function stringToArray(argument: string | string[]): string[];
+//# sourceMappingURL=stringToArray.d.ts.map

package/esm/helpers/stringToArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringToArray.d.ts","sourceRoot":"","sources":["../../src/helpers/stringToArray.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ3E"}

package/esm/helpers/stringToArray.js

@@ -0,0 +1,11 @@
+export default function stringToArray(argument) {
+    if (Array.isArray(argument)) {
+        return argument;
+    }
+    else if (typeof argument === "string") {
+        return [argument];
+    }
+    else {
+        throw new Error(`argument should be a string or an array of strings.`);
+    }
+}

package/esm/helpers/stringifyDates.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function stringifyDates(simpleTable: SimpleTable, types: {
+    [key: string]: string;
+}): Promise<void>;
+//# sourceMappingURL=stringifyDates.d.ts.map

package/esm/helpers/stringifyDates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyDates.d.ts","sourceRoot":"","sources":["../../src/helpers/stringifyDates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,cAAc,CAC1C,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,iBAcjC"}

package/esm/helpers/stringifyDates.js

@@ -0,0 +1,14 @@
+export default async function stringifyDates(simpleTable, types) {
+    const typesKeys = Object.keys(types);
+    const typesValues = Object.values(types);
+    const toConvert = {};
+    for (let i = 0; i < typesKeys.length; i++) {
+        if (typesValues[i] === "TIMESTAMP" || typesValues[i] === "DATE") {
+            toConvert[typesKeys[i]] = "string";
+        }
+    }
+    if (Object.keys(toConvert).length > 0) {
+        await simpleTable.convert(toConvert, { datetimeFormat: "%xT%T.%g%z" });
+        await simpleTable.replace(Object.keys(toConvert), { "+00": "Z" });
+    }
+}

package/esm/helpers/stringifyDatesInvert.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function stringifyDatesInvert(simpleTable: SimpleTable, types: {
+    [key: string]: string;
+}): Promise<void>;
+//# sourceMappingURL=stringifyDatesInvert.d.ts.map

package/esm/helpers/stringifyDatesInvert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyDatesInvert.d.ts","sourceRoot":"","sources":["../../src/helpers/stringifyDatesInvert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,oBAAoB,CAChD,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,iBAgBjC"}

package/esm/helpers/stringifyDatesInvert.js

@@ -0,0 +1,14 @@
+export default async function stringifyDatesInvert(simpleTable, types) {
+    const typesKeys = Object.keys(types);
+    const typesValues = Object.values(types);
+    const toConvertBack = {};
+    for (let i = 0; i < typesKeys.length; i++) {
+        if (typesValues[i] === "TIMESTAMP" || typesValues[i] === "DATE") {
+            toConvertBack[typesKeys[i]] = typesValues[i].toLowerCase();
+        }
+    }
+    if (Object.keys(toConvertBack).length > 0) {
+        await simpleTable.replace(Object.keys(toConvertBack), { "Z": "+00" });
+        await simpleTable.convert(toConvertBack);
+    }
+}

package/esm/helpers/unifyColumns.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function unifyColumns(allTables: SimpleTable[], allTypes: {
+    [key: string]: string;
+}, allProjections: {
+    [key: string]: string;
+}): Promise<{
+    [key: string]: string[];
+}>;
+//# sourceMappingURL=unifyColumns.d.ts.map

package/esm/helpers/unifyColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unifyColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/unifyColumns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,YAAY,CACxC,SAAS,EAAE,WAAW,EAAE,EACxB,QAAQ,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE;;GA4C1C"}

package/esm/helpers/unifyColumns.js

@@ -0,0 +1,21 @@
+export default async function unifyColumns(allTables, allTypes, allProjections) {
+    const columnsAdded = {};
+    for (const column in allTypes) {
+        for (const table of allTables) {
+            if (!(await table.hasColumn(column))) {
+                await table.addColumn(column, 
+                // Could be improved
+                allTypes[column].toLowerCase(), `null`, {
+                    projection: allTypes[column] === "GEOMETRY"
+                        ? allProjections[column]
+                        : undefined,
+                });
+                if (!columnsAdded[table.name]) {
+                    columnsAdded[table.name] = [];
+                }
+                columnsAdded[table.name].push(column);
+            }
+        }
+    }
+    return columnsAdded;
+}

package/esm/helpers/unnestQuery.d.ts

@@ -0,0 +1,2 @@
+export default function unnestQuery(table: string, column: string, separator: string): string;
+//# sourceMappingURL=unnestQuery.d.ts.map

package/esm/helpers/unnestQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unnestQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/unnestQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,UASlB"}

package/esm/helpers/unnestQuery.js

@@ -0,0 +1,8 @@
+export default function unnestQuery(table, column, separator) {
+    const query = `CREATE OR REPLACE TABLE "${table}" AS
+SELECT
+  * EXCLUDE "${column}",
+  TRIM(UNNEST(SPLIT("${column}", '${separator}'))) AS "${column}"
+FROM "${table}";`;
+    return query;
+}

package/esm/helpers/wrapString.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Wraps a string to a specified maximum width, attempting to break at word
+ * boundaries when possible. If a single word exceeds the maximum width, it
+ * will be broken at the character boundary. This function is primarily used
+ * for preparing text to be displayed in console tables.
+ *
+ * @param str - The string to wrap.
+ * @param maxWidth - The maximum width of each line.
+ * @param wordWrap - If true, attempts to break at word boundaries. If false,
+ *   breaks at character boundaries. Defaults to `true`.
+ * @returns The wrapped string with newline characters inserted at appropriate
+ *   positions.
+ *
+ * @example
+ * ```typescript
+ * const text = "This is a very long sentence that needs to be wrapped";
+ * const wrapped = wrapString(text, 20);
+ * console.log(wrapped);
+ * // Output:
+ * // This is a very long
+ * // sentence that needs
+ * // to be wrapped
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Character-based wrapping (no word boundaries)
+ * const text = "Thisisaverylongword";
+ * const wrapped = wrapString(text, 10, false);
+ * // Output: Thisisaver
+ * //         ylongword
+ * ```
+ */
+export default function wrapString(str: string, maxWidth: number, wordWrap?: boolean): string;
+//# sourceMappingURL=wrapString.d.ts.map

package/esm/helpers/wrapString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapString.d.ts","sourceRoot":"","sources":["../../src/helpers/wrapString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAO,GACd,MAAM,CAqDR"}

package/esm/helpers/wrapString.js

@@ -0,0 +1,83 @@
+/**
+ * Wraps a string to a specified maximum width, attempting to break at word
+ * boundaries when possible. If a single word exceeds the maximum width, it
+ * will be broken at the character boundary. This function is primarily used
+ * for preparing text to be displayed in console tables.
+ *
+ * @param str - The string to wrap.
+ * @param maxWidth - The maximum width of each line.
+ * @param wordWrap - If true, attempts to break at word boundaries. If false,
+ *   breaks at character boundaries. Defaults to `true`.
+ * @returns The wrapped string with newline characters inserted at appropriate
+ *   positions.
+ *
+ * @example
+ * ```typescript
+ * const text = "This is a very long sentence that needs to be wrapped";
+ * const wrapped = wrapString(text, 20);
+ * console.log(wrapped);
+ * // Output:
+ * // This is a very long
+ * // sentence that needs
+ * // to be wrapped
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Character-based wrapping (no word boundaries)
+ * const text = "Thisisaverylongword";
+ * const wrapped = wrapString(text, 10, false);
+ * // Output: Thisisaver
+ * //         ylongword
+ * ```
+ */
+export default function wrapString(str, maxWidth, wordWrap = true) {
+    if (str.length <= maxWidth) {
+        return str;
+    }
+    if (!wordWrap) {
+        // Simple character-based wrapping
+        const lines = [];
+        for (let i = 0; i < str.length; i += maxWidth) {
+            lines.push(str.slice(i, i + maxWidth));
+        }
+        return lines.join("\n");
+    }
+    // Word-aware wrapping
+    const lines = [];
+    let currentLine = "";
+    const words = str.split(/(\s+)/); // Split but keep whitespace
+    for (const word of words) {
+        // If adding this word would exceed maxWidth
+        if (currentLine.length + word.length > maxWidth) {
+            // If current line is not empty, save it
+            if (currentLine.length > 0) {
+                lines.push(currentLine.trimEnd());
+                currentLine = "";
+            }
+            // If the word itself is longer than maxWidth, break it
+            if (word.length > maxWidth) {
+                for (let i = 0; i < word.length; i += maxWidth) {
+                    const chunk = word.slice(i, i + maxWidth);
+                    if (i + maxWidth < word.length) {
+                        lines.push(chunk);
+                    }
+                    else {
+                        currentLine = chunk;
+                    }
+                }
+            }
+            else {
+                currentLine = word;
+            }
+        }
+        else {
+            currentLine += word;
+        }
+    }
+    // Add any remaining text
+    if (currentLine.length > 0) {
+        lines.push(currentLine.trimEnd());
+    }
+    return lines.join("\n");
+}

package/esm/helpers/writeDataAsArrays.d.ts

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

package/esm/helpers/writeDataAsArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeDataAsArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/writeDataAsArrays.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,iBAAiB,CAC7C,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,iBASb"}

package/esm/helpers/writeDataAsArrays.js

@@ -0,0 +1,13 @@
+import dataToArrays from "./dataToArrays.js";
+import getExtension from "./getExtension.js";
+import { writeFileSync } from "node:fs";
+export default async function writeDataAsArrays(simpleTable, file) {
+    const fileExtension = getExtension(file);
+    if (fileExtension === "json") {
+        const data = await simpleTable.getData();
+        writeFileSync(file, JSON.stringify(dataToArrays(data)));
+    }
+    else {
+        throw new Error("The option dataAsArrays works only with json files.");
+    }
+}

package/esm/helpers/writeProjectionsAndIndexes.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleDB } from "../index.js";
+export default function writeProjectionsAndIndexes(simpleDB: SimpleDB, extension: string, file: string): void;
+//# sourceMappingURL=writeProjectionsAndIndexes.d.ts.map

package/esm/helpers/writeProjectionsAndIndexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeProjectionsAndIndexes.d.ts","sourceRoot":"","sources":["../../src/helpers/writeProjectionsAndIndexes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAChD,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,QA+Bb"}

package/esm/helpers/writeProjectionsAndIndexes.js

@@ -0,0 +1,29 @@
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+export default function writeProjectionsAndIndexes(simpleDB, extension, file) {
+    const allProjections = {};
+    for (const table of simpleDB.tables) {
+        if (Object.keys(table.projections).length > 0) {
+            allProjections[table.name] = table.projections;
+        }
+    }
+    const allProjectionsFile = `${file.replace(`.${extension}`, "")}_projections.json`;
+    if (existsSync(allProjectionsFile)) {
+        rmSync(allProjectionsFile);
+    }
+    if (Object.keys(allProjections).length > 0) {
+        writeFileSync(allProjectionsFile, JSON.stringify(allProjections));
+    }
+    const allIndexes = {};
+    for (const table of simpleDB.tables) {
+        if (table.indexes.length > 0) {
+            allIndexes[table.name] = table.indexes;
+        }
+    }
+    const allIndexesFile = `${file.replace(`.${extension}`, "")}_indexes.json`;
+    if (existsSync(allIndexesFile)) {
+        rmSync(allIndexesFile);
+    }
+    if (Object.keys(allIndexes).length > 0) {
+        writeFileSync(allIndexesFile, JSON.stringify(allIndexes));
+    }
+}

package/esm/index.d.ts

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

package/esm/index.d.ts.map

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

package/esm/index.js

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

package/esm/methods/aggregateGeoQuery.d.ts

@@ -0,0 +1,5 @@
+export default function aggregateGeoQuery(table: string, column: string, method: "union" | "intersection", options?: {
+    categories?: string | string[];
+    outputTable?: string | boolean;
+}): string;
+//# sourceMappingURL=aggregateGeoQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateGeoQuery.d.ts","sourceRoot":"","sources":["../../src/methods/aggregateGeoQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,GAAG,cAAc,EAChC,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,UA4BP"}

package/esm/methods/aggregateGeoQuery.js

@@ -0,0 +1,24 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function aggregateGeoQuery(table, column, method, options = {}) {
+    const categoriesOptions = options.categories ?? [];
+    const categories = stringToArray(categoriesOptions);
+    let query = `CREATE OR REPLACE TABLE "${options.outputTable ?? table}" AS
+    SELECT${categories.length > 0
+        ? ` ${categories.map((d) => `"${d}"`).join(", ")},`
+        : ""}`;
+    if (method === "union") {
+        query += ` ST_Union_Agg("${column}") AS "${column}"`;
+    }
+    else if (method === "intersection") {
+        query += ` ST_Intersection_Agg("${column}") AS "${column}"`;
+    }
+    else {
+        throw new Error(`Unkown method ${method}`);
+    }
+    query += `\nFROM "${table}"`;
+    if (categories.length > 0) {
+        query += `\nGROUP BY ${categories.map((d) => `"${d}"`).join(", ")}`;
+        query += `\nORDER BY ${categories.map((d) => `"${d}" ASC`).join(", ")}`;
+    }
+    return query;
+}

package/esm/methods/binsQuery.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"binsQuery.d.ts","sourceRoot":"","sources":["../../src/methods/binsQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,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,mBAkDP"}

package/esm/methods/binsQuery.js

@@ -0,0 +1,40 @@
+export default async function binsQuery(SimpleTable, values, interval, newColumn, options = {}) {
+    const minValue = await SimpleTable.getMin(values);
+    if (typeof minValue !== "number") {
+        throw new Error(`minValue of ${values} is not a number`);
+    }
+    let startValue = 0;
+    if (typeof options.startValue === "number") {
+        if (startValue > minValue) {
+            throw new Error(`startValue ${options.startValue} can't be greater than minValue ${minValue}`);
+        }
+        startValue = options.startValue;
+    }
+    else {
+        startValue = minValue;
+    }
+    const maxValue = await SimpleTable.getMax(values);
+    if (typeof maxValue !== "number") {
+        throw new Error(`maxValue of ${values} 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 "${values}" >= ${start} AND "${values}" <= ${end} THEN '[${start}-${end}]'`);
+    }
+    const query = `ALTER TABLE "${SimpleTable.name}" ADD "${newColumn}" VARCHAR;
+    UPDATE "${SimpleTable.name}" SET "${newColumn}" = CASE
+    ${intervals.join("\n")}
+    END`;
+    return query;
+}

package/esm/methods/bm25.d.ts

@@ -0,0 +1,17 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function bm25(simpleTable: SimpleTable, text: string, columnId: string, columnText: string, nbResults: 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;
+}): Promise<SimpleTable>;
+//# sourceMappingURL=bm25.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bm25.d.ts","sourceRoot":"","sources":["../../src/methods/bm25.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,IAAI,CAChC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,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,wBAgEP"}

package/esm/methods/bm25.js

@@ -0,0 +1,48 @@
+import camelCase from "../helpers/camelCase.js";
+import queryDB from "../helpers/queryDB.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+export default async function bm25(simpleTable, text, columnId, columnText, nbResults, options = {}) {
+    // This uses the fts extension
+    // https://duckdb.org/docs/stable/core_extensions/full_text_search
+    await simpleTable.createFtsIndex(columnId, columnText, {
+        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 "${options.scoreColumn}"`
+        : `* EXCLUDE(score)`;
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE "${options.outputTable ?? simpleTable.name}" AS SELECT ${selectClause} FROM (SELECT *, fts_main_${camelCase(simpleTable.name)}.match_bm25(${columnId}, '${text.replace(/'/g, "''")}'${typeof options.k === "number" ? `, k := ${options.k}` : ""}${typeof options.b === "number" ? `, b := ${options.b}` : ""}${options.conjunctive === true ? `, conjunctive := 1` : ""}) AS score FROM "${simpleTable.name}") sq WHERE score NOT NULL${minScoreCondition} ORDER BY score DESC LIMIT ${nbResults};`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "bm25",
+        parameters: {
+            text,
+            columnId,
+            columnText,
+            nbResults,
+            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,
+        },
+    }));
+    if (typeof options.outputTable === "string") {
+        return simpleTable.sdb.newTable(options.outputTable, structuredClone(simpleTable.projections));
+    }
+    else {
+        return simpleTable;
+    }
+}