@nshiab/simple-data-analysis-core 0.0.12

package/esm/helpers/accumulateQuery.d.ts

@@ -0,0 +1,4 @@
+export default function accumulateQuery(table: string, column: string, newColumn: string, options?: {
+    categories?: string | string[];
+}): string;
+//# sourceMappingURL=accumulateQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accumulateQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/accumulateQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B,UAiBP"}

package/esm/helpers/accumulateQuery.js

@@ -0,0 +1,15 @@
+import stringToArray from "./stringToArray.js";
+export default function accumulateQuery(table, column, newColumn, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories)
+        : [];
+    const partition = categories.length > 0
+        ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")} `
+        : "";
+    const query = `CREATE OR REPLACE TABLE "${table}" AS SELECT *, ROW_NUMBER() OVER() AS "idForAccumulate" FROM "${table}";
+    CREATE OR REPLACE TABLE "${table}" AS SELECT *, SUM("${column}") OVER (${partition}ORDER BY "idForAccumulate") AS "${newColumn}"
+    FROM "${table}"
+    ORDER BY "idForAccumulate";
+    ALTER TABLE "${table}" DROP "idForAccumulate";`;
+    return query;
+}

package/esm/helpers/camelCase.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Converts a string into camelCase. This is useful for creating variable
+ * names or object keys from human-readable text.
+ *
+ * @param input - The string to convert to camelCase. It can contain spaces,
+ *   punctuation, and mixed casing.
+ *
+ * @returns The camelCased version of the input string.
+ *
+ * @example
+ * ```ts
+ * // Basic conversion
+ * const result1 = camelCase("hello world");
+ * console.log(result1); // "helloWorld"
+ * ```
+ * @example
+ * ```ts
+ * // With punctuation and mixed case
+ * const result2 = camelCase("  --Some@Thing is- happening--  ");
+ * console.log(result2); // "someThingIsHappening"
+ * ```
+ * @example
+ * ```ts
+ * // With a single word
+ * const result3 = camelCase("Journalism");
+ * console.log(result3); // "journalism"
+ * ```
+ */
+export default function camelCase(input: string): string;
+//# sourceMappingURL=camelCase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../src/helpers/camelCase.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBvD"}

package/esm/helpers/camelCase.js

@@ -0,0 +1,45 @@
+import capitalize from "./capitalize.js";
+/**
+ * Converts a string into camelCase. This is useful for creating variable
+ * names or object keys from human-readable text.
+ *
+ * @param input - The string to convert to camelCase. It can contain spaces,
+ *   punctuation, and mixed casing.
+ *
+ * @returns The camelCased version of the input string.
+ *
+ * @example
+ * ```ts
+ * // Basic conversion
+ * const result1 = camelCase("hello world");
+ * console.log(result1); // "helloWorld"
+ * ```
+ * @example
+ * ```ts
+ * // With punctuation and mixed case
+ * const result2 = camelCase("  --Some@Thing is- happening--  ");
+ * console.log(result2); // "someThingIsHappening"
+ * ```
+ * @example
+ * ```ts
+ * // With a single word
+ * const result3 = camelCase("Journalism");
+ * console.log(result3); // "journalism"
+ * ```
+ */
+export default function camelCase(input) {
+    const words = input
+        .replace(/[^a-zA-Z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((d) => d !== "");
+    const camelCaseString = words
+        .map((word, index) => {
+        word = word.toLowerCase();
+        if (index > 0) {
+            word = capitalize(word);
+        }
+        return word;
+    })
+        .join("");
+    return camelCaseString;
+}

package/esm/helpers/capitalize.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Capitalizes the first letter of a given string.
+ *
+ * @param string - The string to be capitalized.
+ *
+ * @returns A new string with the first letter in uppercase.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const capitalized = capitalize("hello world");
+ * console.log(capitalized); // "Hello world"
+ * ```
+ * @example
+ * ```ts
+ * // With an already capitalized string
+ * const alreadyCapitalized = capitalize("Journalism");
+ * console.log(alreadyCapitalized); // "Journalism"
+ * ```
+ * @example
+ * ```ts
+ * // With a single character
+ * const singleChar = capitalize("a");
+ * console.log(singleChar); // "A"
+ * ```
+ */
+export default function capitalize(string: string): string;
+//# sourceMappingURL=capitalize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.d.ts","sourceRoot":"","sources":["../../src/helpers/capitalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMzD"}

package/esm/helpers/capitalize.js

@@ -0,0 +1,33 @@
+/**
+ * Capitalizes the first letter of a given string.
+ *
+ * @param string - The string to be capitalized.
+ *
+ * @returns A new string with the first letter in uppercase.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const capitalized = capitalize("hello world");
+ * console.log(capitalized); // "Hello world"
+ * ```
+ * @example
+ * ```ts
+ * // With an already capitalized string
+ * const alreadyCapitalized = capitalize("Journalism");
+ * console.log(alreadyCapitalized); // "Journalism"
+ * ```
+ * @example
+ * ```ts
+ * // With a single character
+ * const singleChar = capitalize("a");
+ * console.log(singleChar); // "A"
+ * ```
+ */
+export default function capitalize(string) {
+    if (string.length === 0) {
+        return string;
+    }
+    const first = string[0];
+    return first.toUpperCase() + string.slice(1);
+}

package/esm/helpers/checkVssIndexes.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkVssIndexes.d.ts","sourceRoot":"","sources":["../../src/helpers/checkVssIndexes.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAevE"}

package/esm/helpers/checkVssIndexes.js

@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+export default function checkVssIndexes(allIndexesFile) {
+    let vssIndex = false;
+    if (existsSync(allIndexesFile)) {
+        const indexes = JSON.parse(readFileSync(allIndexesFile, "utf-8"));
+        for (const table of Object.keys(indexes)) {
+            for (const index of indexes[table]) {
+                if (index.startsWith("vss_")) {
+                    vssIndex = true;
+                }
+            }
+        }
+    }
+    return vssIndex;
+}

package/esm/helpers/cleanCache.d.ts

@@ -0,0 +1,3 @@
+import type SimpleDB from "../class/SimpleDB.js";
+export default function cleanCache(sdb: SimpleDB): void;
+//# sourceMappingURL=cleanCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cleanCache.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAEjD,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,GAAG,EAAE,QAAQ,QAmB/C"}

package/esm/helpers/cleanCache.js

@@ -0,0 +1,17 @@
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+export default function cleanCache(sdb) {
+    if (sdb.cacheSourcesUsed.length > 0) {
+        const cacheSources = JSON.parse(readFileSync(".sda-cache/sources.json", "utf-8"));
+        for (const cacheId of Object.keys(cacheSources)) {
+            if (!sdb.cacheSourcesUsed.includes(cacheId)) {
+                if (cacheSources[cacheId].file !== null) {
+                    sdb.debug &&
+                        console.log(`Removing unused file from cache: ${cacheSources[cacheId].file}`);
+                    unlinkSync(cacheSources[cacheId].file);
+                }
+                delete cacheSources[cacheId];
+            }
+        }
+        writeFileSync(".sda-cache/sources.json", JSON.stringify(cacheSources));
+    }
+}

package/esm/helpers/cleanPath.d.ts

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

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

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

package/esm/helpers/cleanPath.js

@@ -0,0 +1,3 @@
+export default function cleanPath(file) {
+    return file.replaceAll("'", "''");
+}

package/esm/helpers/cleanSQL.d.ts

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

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

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

package/esm/helpers/cleanSQL.js

@@ -0,0 +1,24 @@
+export default function cleanSQL(query) {
+    // First pass
+    let cleaned = query
+        .replace(/ && /g, " AND ")
+        .replace(/ === /g, " = ")
+        .replace(/ == /g, " = ")
+        .replace(/ !== /g, " != ");
+    // Replace || with OR only in WHERE clauses (for logical operations)
+    // Preserve || elsewhere as it's the SQL concatenation operator
+    cleaned = cleaned.replace(/WHERE\s+([\s\S]*?)(?=\s+(?:GROUP BY|ORDER BY|LIMIT|HAVING)|$)/gi, (match) => {
+        return match.replace(/\s*\|\|\s*/g, " OR ");
+    });
+    if (cleaned.includes("ALTER TABLE") && cleaned.includes("UPDATE") &&
+        cleaned.includes("SET")) {
+        // We pass
+    }
+    else {
+        // We do a second pass
+        cleaned = cleaned.replace(/ null(?=\s|$)/g, " NULL") // space after or end of string
+            .replace(/ != NULL/g, " NOT NULL")
+            .replace(/ = NULL/g, " IS NULL");
+    }
+    return cleaned.trim();
+}

package/esm/helpers/concatenateRowQuery.d.ts

@@ -0,0 +1,2 @@
+export default function concatenateRowQuery(table: string, columns: string[], newColumn: string): string;
+//# sourceMappingURL=concatenateRowQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concatenateRowQuery.d.ts","sourceRoot":"","sources":["../../src/helpers/concatenateRowQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,MAAM,UAclB"}

package/esm/helpers/concatenateRowQuery.js

@@ -0,0 +1,9 @@
+export default function concatenateRowQuery(table, columns, newColumn) {
+    const parts = columns.map((col, i) => i === 0
+        ? `'${col}:\n' || COALESCE("${col}", 'Unknown')`
+        : `'\n\n${col}:\n' || COALESCE("${col}", 'Unknown')`);
+    const concatenatedExpression = parts.join(" || ");
+    const query = `ALTER TABLE "${table}" ADD "${newColumn}" VARCHAR;
+    UPDATE "${table}" SET "${newColumn}" = ${concatenatedExpression}`;
+    return query;
+}

package/esm/helpers/convertForJS.d.ts

@@ -0,0 +1,6 @@
+export default function convertForJS(rows: {
+    [key: string]: string | number | boolean | Date | null;
+}[], types: {
+    [key: string]: string;
+}): void;
+//# sourceMappingURL=convertForJS.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convertForJS.d.ts","sourceRoot":"","sources":["../../src/helpers/convertForJS.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,IAAI,EAAE;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;CACxD,EAAE,EAAE,KAAK,EAAE;IACV,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB,QAkCA"}

package/esm/helpers/convertForJS.js

@@ -0,0 +1,39 @@
+export default function convertForJS(rows, types) {
+    if (rows[0] !== undefined) {
+        const firstObjectKeys = Object.keys(rows[0]);
+        for (const key of Object.keys(types)) {
+            if (!firstObjectKeys.includes(key)) {
+                continue;
+            }
+            if (types[key] === "DATE") {
+                for (const row of rows) {
+                    row[key] = row[key] === null
+                        ? null
+                        : new Date(`${row[key]}T00:00:00.000Z`);
+                }
+            }
+            else if (types[key] === "TIMESTAMP") {
+                for (const row of rows) {
+                    row[key] = row[key] === null
+                        ? null
+                        : new Date(row[key].replace(" ", "T") + "Z");
+                }
+            }
+            else if (types[key] === "BIGINT" || types[key] === "HUGEINT") {
+                for (const row of rows) {
+                    row[key] = row[key] === null ? null : Number(row[key]);
+                }
+            }
+            else if (types[key] === "GEOMETRY") {
+                for (const row of rows) {
+                    row[key] = row[key] === null ? null : "<Geometry>";
+                }
+            }
+            else if (types[key].includes("FLOAT[")) {
+                for (const row of rows) {
+                    row[key] = row[key] === null ? null : `<${types[key]}>`;
+                }
+            }
+        }
+    }
+}

package/esm/helpers/createDirectory.d.ts

@@ -0,0 +1,2 @@
+export default function createDirectory(path: string): void;
+//# sourceMappingURL=createDirectory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDirectory.d.ts","sourceRoot":"","sources":["../../src/helpers/createDirectory.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAS1D"}

package/esm/helpers/createDirectory.js

@@ -0,0 +1,10 @@
+import { existsSync, mkdirSync } from "node:fs";
+export default function createDirectory(path) {
+    path = path
+        .split("/")
+        .filter((d) => (d.startsWith(".") ? true : !d.includes(".")))
+        .join("/");
+    if (path !== "" && !existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+    }
+}

package/esm/helpers/csvFormat.d.ts

@@ -0,0 +1,3 @@
+declare var csvFormat_default: any;
+export { csvFormat_default as default };
+//# sourceMappingURL=csvFormat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csvFormat.d.ts","sourceRoot":"","sources":["../../src/helpers/csvFormat.ts"],"names":[],"mappings":"AAuJA,QAAA,IAAI,iBAAiB,EAAE,GAAe,CAAC;AACvC,OAAO,EACL,iBAAiB,IAAI,OAAO,EAC7B,CAAC"}

package/esm/helpers/csvFormat.js

@@ -0,0 +1,165 @@
+// @ts-nocheck
+// deno-lint-ignore-file
+// Created by bundling csvFormat from d3-dsv.
+// Original source: https://github.com/d3/d3-dsv
+// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/dsv.js
+var EOL = {};
+var EOF = {};
+var QUOTE = 34;
+var NEWLINE = 10;
+var RETURN = 13;
+function objectConverter(columns) {
+    return new Function("d", "return {" + columns.map(function (name, i) {
+        return JSON.stringify(name) + ": d[" + i + '] || ""';
+    }).join(",") + "}");
+}
+function customConverter(columns, f) {
+    var object = objectConverter(columns);
+    return function (row, i) {
+        return f(object(row), i, columns);
+    };
+}
+function inferColumns(rows) {
+    var columnSet = /* @__PURE__ */ Object.create(null), columns = [];
+    rows.forEach(function (row) {
+        for (var column in row) {
+            if (!(column in columnSet)) {
+                columns.push(columnSet[column] = column);
+            }
+        }
+    });
+    return columns;
+}
+function pad(value, width) {
+    var s = value + "", length = s.length;
+    return length < width ? new Array(width - length + 1).join(0) + s : s;
+}
+function formatYear(year) {
+    return year < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4);
+}
+function formatDate(date) {
+    var hours = date.getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds();
+    return isNaN(date) ? "Invalid Date" : formatYear(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "");
+}
+function dsv_default(delimiter) {
+    var reFormat = new RegExp('["' + delimiter + "\n\r]"), DELIMITER = delimiter.charCodeAt(0);
+    function parse(text, f) {
+        var convert, columns, rows = parseRows(text, function (row, i) {
+            if (convert)
+                return convert(row, i - 1);
+            columns = row, convert = f ? customConverter(row, f) : objectConverter(row);
+        });
+        rows.columns = columns || [];
+        return rows;
+    }
+    function parseRows(text, f) {
+        var rows = [], N = text.length, I = 0, n = 0, t, eof = N <= 0, eol = false;
+        if (text.charCodeAt(N - 1) === NEWLINE)
+            --N;
+        if (text.charCodeAt(N - 1) === RETURN)
+            --N;
+        function token() {
+            if (eof)
+                return EOF;
+            if (eol)
+                return eol = false, EOL;
+            var i, j = I, c;
+            if (text.charCodeAt(j) === QUOTE) {
+                while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE)
+                    ;
+                if ((i = I) >= N)
+                    eof = true;
+                else if ((c = text.charCodeAt(I++)) === NEWLINE)
+                    eol = true;
+                else if (c === RETURN) {
+                    eol = true;
+                    if (text.charCodeAt(I) === NEWLINE)
+                        ++I;
+                }
+                return text.slice(j + 1, i - 1).replace(/""/g, '"');
+            }
+            while (I < N) {
+                if ((c = text.charCodeAt(i = I++)) === NEWLINE)
+                    eol = true;
+                else if (c === RETURN) {
+                    eol = true;
+                    if (text.charCodeAt(I) === NEWLINE)
+                        ++I;
+                }
+                else if (c !== DELIMITER)
+                    continue;
+                return text.slice(j, i);
+            }
+            return eof = true, text.slice(j, N);
+        }
+        while ((t = token()) !== EOF) {
+            var row = [];
+            while (t !== EOL && t !== EOF)
+                row.push(t), t = token();
+            if (f && (row = f(row, n++)) == null)
+                continue;
+            rows.push(row);
+        }
+        return rows;
+    }
+    function preformatBody(rows, columns) {
+        return rows.map(function (row) {
+            return columns.map(function (column) {
+                return formatValue(row[column]);
+            }).join(delimiter);
+        });
+    }
+    function format(rows, columns) {
+        if (columns == null)
+            columns = inferColumns(rows);
+        return [
+            columns.map(formatValue).join(delimiter)
+        ].concat(preformatBody(rows, columns)).join("\n");
+    }
+    function formatBody(rows, columns) {
+        if (columns == null)
+            columns = inferColumns(rows);
+        return preformatBody(rows, columns).join("\n");
+    }
+    function formatRows(rows) {
+        return rows.map(formatRow).join("\n");
+    }
+    function formatRow(row) {
+        return row.map(formatValue).join(delimiter);
+    }
+    function formatValue(value) {
+        return value == null ? "" : value instanceof Date ? formatDate(value) : reFormat.test(value += "") ? '"' + value.replace(/"/g, '""') + '"' : value;
+    }
+    return {
+        parse,
+        parseRows,
+        format,
+        formatBody,
+        formatRows,
+        formatRow,
+        formatValue
+    };
+}
+// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/csv.js
+var csv = dsv_default(",");
+var csvParse = csv.parse;
+var csvParseRows = csv.parseRows;
+var csvFormat = csv.format;
+var csvFormatBody = csv.formatBody;
+var csvFormatRows = csv.formatRows;
+var csvFormatRow = csv.formatRow;
+var csvFormatValue = csv.formatValue;
+// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/tsv.js
+var tsv = dsv_default("	");
+var tsvParse = tsv.parse;
+var tsvParseRows = tsv.parseRows;
+var tsvFormat = tsv.format;
+var tsvFormatBody = tsv.formatBody;
+var tsvFormatRows = tsv.formatRows;
+var tsvFormatRow = tsv.formatRow;
+var tsvFormatValue = tsv.formatValue;
+// node_modules/.deno/d3-dsv@3.0.1/node_modules/d3-dsv/src/autoType.js
+var fixtz = ( /* @__PURE__ */new Date("2019-01-01T00:00")).getHours() || ( /* @__PURE__ */new Date("2019-07-01T00:00")).getHours();
+// tmp/csvFormat.ts
+var csvFormat_default = csvFormat;
+export { csvFormat_default as default };

package/esm/helpers/dataToArrays.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
+ *
+ * @param data An array of objects. Each object is expected to have the same set of keys.
+ *
+ * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const rowData = [
+ *   { name: 'Alice', age: 30, city: 'New York' },
+ *   { name: 'Bob', age: 25, city: 'London' },
+ *   { name: 'Charlie', age: 35, city: 'Paris' }
+ * ];
+ *
+ * const columnarData = dataToArrays(rowData);
+ *
+ * console.log(columnarData);
+ * // Expected output:
+ * // {
+ * //   name: ['Alice', 'Bob', 'Charlie'],
+ * //   age: [30, 25, 35],
+ * //   city: ['New York', 'London', 'Paris']
+ * // }
+ * ```
+ * @example
+ * ```ts
+ * // Preparing data for statistical analysis
+ * const measurements = [
+ *   { id: 1, temp: 20, humidity: 60 },
+ *   { id: 2, temp: 22, humidity: 65 },
+ *   { id: 3, temp: 18, humidity: 55 }
+ * ];
+ *
+ * const separatedVariables = dataToArrays(measurements);
+ *
+ * console.log(separatedVariables);
+ * // Expected output:
+ * // {
+ * //   id: [1, 2, 3],
+ * //   temp: [20, 22, 18],
+ * //   humidity: [60, 65, 55]
+ * // }
+ * ```
+ * @category Formatting
+ */
+export default function dataToArrays<T extends Record<string, unknown>>(data: T[]): {
+    [K in keyof T]: T[K][];
+};
+//# sourceMappingURL=dataToArrays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataToArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/dataToArrays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,IAAI,EAAE,CAAC,EAAE,GACR;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;CAAE,CAU5B"}

package/esm/helpers/dataToArrays.js

@@ -0,0 +1,55 @@
+/**
+ * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
+ *
+ * @param data An array of objects. Each object is expected to have the same set of keys.
+ *
+ * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const rowData = [
+ *   { name: 'Alice', age: 30, city: 'New York' },
+ *   { name: 'Bob', age: 25, city: 'London' },
+ *   { name: 'Charlie', age: 35, city: 'Paris' }
+ * ];
+ *
+ * const columnarData = dataToArrays(rowData);
+ *
+ * console.log(columnarData);
+ * // Expected output:
+ * // {
+ * //   name: ['Alice', 'Bob', 'Charlie'],
+ * //   age: [30, 25, 35],
+ * //   city: ['New York', 'London', 'Paris']
+ * // }
+ * ```
+ * @example
+ * ```ts
+ * // Preparing data for statistical analysis
+ * const measurements = [
+ *   { id: 1, temp: 20, humidity: 60 },
+ *   { id: 2, temp: 22, humidity: 65 },
+ *   { id: 3, temp: 18, humidity: 55 }
+ * ];
+ *
+ * const separatedVariables = dataToArrays(measurements);
+ *
+ * console.log(separatedVariables);
+ * // Expected output:
+ * // {
+ * //   id: [1, 2, 3],
+ * //   temp: [20, 22, 18],
+ * //   humidity: [60, 65, 55]
+ * // }
+ * ```
+ * @category Formatting
+ */
+export default function dataToArrays(data) {
+    const newData = {};
+    const keys = Object.keys(data[0]);
+    for (const key of keys) {
+        newData[key] = data.map((d) => d[key]);
+    }
+    return newData;
+}

package/esm/helpers/extractTypes.d.ts

@@ -0,0 +1,6 @@
+export default function extractTypes(types: {
+    [key: string]: string | number | boolean | Date | null;
+}[] | null): {
+    [key: string]: string;
+};
+//# sourceMappingURL=extractTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractTypes.d.ts","sourceRoot":"","sources":["../../src/helpers/extractTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;CACxD,EAAE,GAAG,IAAI;;EAaX"}