@nshiab/simple-data-analysis-core 0.0.12

package/script/helpers/dataToArrays.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dataToArrays;
+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/script/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/script/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"}

package/script/helpers/extractTypes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractTypes;
+function extractTypes(types) {
+    const typesObj = {};
+    if (types) {
+        for (const t of types) {
+            if (t.column_name) {
+                typesObj[t.column_name] = t.column_type;
+            }
+        }
+    }
+    return typesObj;
+}

package/script/helpers/findGeoColumn.d.ts

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

package/script/helpers/findGeoColumn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findGeoColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/findGeoColumn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,aAAa,CAAC,WAAW,EAAE,WAAW,mBAsBnE"}

package/script/helpers/findGeoColumn.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = findGeoColumn;
+async function findGeoColumn(SimpleTable) {
+    let column;
+    const types = await SimpleTable.getTypes();
+    const geometries = Object.values(types).filter((d) => d.toLowerCase() === "geometry");
+    if (geometries.length === 0) {
+        throw new Error("No column storing geometries");
+    }
+    else if (geometries.length > 1) {
+        throw new Error("More than one column storing geometries. If the method allows to specify one, do it. Otherwise, use the selectColumns methods beforehand.");
+    }
+    else {
+        column = Object.keys(types).find((d) => types[d].toLowerCase() === "geometry");
+    }
+    if (typeof column !== "string") {
+        throw new Error("No column");
+    }
+    return column;
+}

package/script/helpers/formatDate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Formats a `Date` object into a human-readable string using only the format
+ * strings actually used in the project.
+ *
+ * @param date - The `Date` object to format.
+ * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
+ * @param options - Optional settings.
+ * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
+ * @returns The formatted date string.
+ *
+ * @example
+ * ```ts
+ * // Format a date with time (local time).
+ * const date = new Date("2023-01-01T01:35:00");
+ * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
+ * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
+ * ```
+ * @example
+ * ```ts
+ * // Format a date as month and day only (UTC).
+ * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
+ * console.log(formatted); // "January 1"
+ * ```
+ * @example
+ * ```ts
+ * // Minutes of ":00" are omitted.
+ * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
+ * console.log(formatted); // "January 1, 2023, at 1 a.m."
+ * ```
+ */
+export default function formatDate(date: Date, format: "Month DD, YYYY, at HH:MM period" | "Month DD", options?: {
+    utc?: boolean;
+}): string;
+//# sourceMappingURL=formatDate.d.ts.map

package/script/helpers/formatDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/helpers/formatDate.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,iCAAiC,GAAG,UAAU,EACtD,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,MAAM,CA2BR"}

package/script/helpers/formatDate.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatDate;
+const MONTHS = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];
+/**
+ * Formats a `Date` object into a human-readable string using only the format
+ * strings actually used in the project.
+ *
+ * @param date - The `Date` object to format.
+ * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
+ * @param options - Optional settings.
+ * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
+ * @returns The formatted date string.
+ *
+ * @example
+ * ```ts
+ * // Format a date with time (local time).
+ * const date = new Date("2023-01-01T01:35:00");
+ * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
+ * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
+ * ```
+ * @example
+ * ```ts
+ * // Format a date as month and day only (UTC).
+ * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
+ * console.log(formatted); // "January 1"
+ * ```
+ * @example
+ * ```ts
+ * // Minutes of ":00" are omitted.
+ * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
+ * console.log(formatted); // "January 1, 2023, at 1 a.m."
+ * ```
+ */
+function formatDate(date, format, options = {}) {
+    const getFullYear = options.utc ? date.getUTCFullYear : date.getFullYear;
+    const getMonth = options.utc ? date.getUTCMonth : date.getMonth;
+    const getDate = options.utc ? date.getUTCDate : date.getDate;
+    const getHours = options.utc ? date.getUTCHours : date.getHours;
+    const getMinutes = options.utc ? date.getUTCMinutes : date.getMinutes;
+    const year = getFullYear.call(date);
+    const month = MONTHS[getMonth.call(date)];
+    const day = getDate.call(date);
+    const hours = getHours.call(date);
+    const minutes = getMinutes.call(date);
+    const period = hours >= 12 ? "p.m." : "a.m.";
+    const displayHours = hours % 12 || 12;
+    const displayMinutes = minutes.toString().padStart(2, "0");
+    if (format === "Month DD, YYYY, at HH:MM period") {
+        const time = minutes === 0
+            ? `${displayHours} ${period}`
+            : `${displayHours}:${displayMinutes} ${period}`;
+        return `${month} ${day}, ${year}, at ${time}`;
+    }
+    else if (format === "Month DD") {
+        return `${month} ${day}`;
+    }
+    return "";
+}

package/script/helpers/formatNumber.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Formats a number with thousands separators, decimals, abbreviations, and more.
+ *
+ * @param number - The number to be formatted.
+ * @param options - An object containing various formatting options.
+ * @param options.decimals - The number of decimal places to round to.
+ * @param options.significantDigits - The number of significant digits to round to.
+ * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
+ * @param options.prefix - A string to prepend before the formatted number.
+ * @param options.suffix - A string to append after the formatted number.
+ *
+ * @returns The formatted number as a string.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: Format a number with thousands separator.
+ * const num1 = formatNumber(1234567.89);
+ * console.log(num1); // "1,234,567.89"
+ * ```
+ * @example
+ * ```ts
+ * // With significant digits and suffix.
+ * const num2 = formatNumber(66.666, { significantDigits: 3, suffix: "%" });
+ * console.log(num2); // "66.7%"
+ * ```
+ * @example
+ * ```ts
+ * // Abbreviation.
+ * const num3 = formatNumber(12000, { abbreviation: true });
+ * console.log(num3); // "12K"
+ * ```
+ * @example
+ * ```ts
+ * // With decimal places.
+ * const num4 = formatNumber(123.456, { decimals: 1 });
+ * console.log(num4); // "123.5"
+ * ```
+ */
+export default function formatNumber(number: number, options?: {
+    decimals?: number;
+    significantDigits?: number;
+    abbreviation?: boolean;
+    prefix?: string;
+    suffix?: string;
+}): string;
+//# sourceMappingURL=formatNumber.d.ts.map

package/script/helpers/formatNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,MAAM,CAgER"}

package/script/helpers/formatNumber.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatNumber;
+/**
+ * Rounds a number based on specified criteria: a fixed number of decimal places or to a specific number of significant digits.
+ *
+ * @param number - The number to be rounded.
+ * @param options - An object containing options for rounding.
+ * @param options.decimals - The number of decimal places to keep when rounding.
+ * @param options.significantDigits - The number of significant digits to retain.
+ * @returns The rounded number.
+ * @throws {Error} If more than one rounding option is provided.
+ *
+ * @example
+ * ```ts
+ * // Round to one decimal place.
+ * const result = round(1234.567, { decimals: 1 });
+ * console.log(result); // 1234.6
+ * ```
+ * @example
+ * ```ts
+ * // Round to 3 significant digits.
+ * const result = round(0.004622, { significantDigits: 3 });
+ * console.log(result); // 0.00462
+ * ```
+ */
+function round(number, options = {}) {
+    if (typeof options.decimals === "number" &&
+        typeof options.significantDigits === "number") {
+        throw new Error("You can't use options decimals and significantDigits together. Pick one.");
+    }
+    if (typeof options.decimals === "number") {
+        return parseFloat(number.toFixed(options.decimals));
+    }
+    else if (typeof options.significantDigits === "number") {
+        return parseFloat(number.toPrecision(options.significantDigits));
+    }
+    else {
+        return Math.round(number);
+    }
+}
+/**
+ * Formats a number with thousands separators, decimals, abbreviations, and more.
+ *
+ * @param number - The number to be formatted.
+ * @param options - An object containing various formatting options.
+ * @param options.decimals - The number of decimal places to round to.
+ * @param options.significantDigits - The number of significant digits to round to.
+ * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
+ * @param options.prefix - A string to prepend before the formatted number.
+ * @param options.suffix - A string to append after the formatted number.
+ *
+ * @returns The formatted number as a string.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: Format a number with thousands separator.
+ * const num1 = formatNumber(1234567.89);
+ * console.log(num1); // "1,234,567.89"
+ * ```
+ * @example
+ * ```ts
+ * // With significant digits and suffix.
+ * const num2 = formatNumber(66.666, { significantDigits: 3, suffix: "%" });
+ * console.log(num2); // "66.7%"
+ * ```
+ * @example
+ * ```ts
+ * // Abbreviation.
+ * const num3 = formatNumber(12000, { abbreviation: true });
+ * console.log(num3); // "12K"
+ * ```
+ * @example
+ * ```ts
+ * // With decimal places.
+ * const num4 = formatNumber(123.456, { decimals: 1 });
+ * console.log(num4); // "123.5"
+ * ```
+ */
+function formatNumber(number, options = {}) {
+    if (typeof number !== "number") {
+        throw new Error("Not a number");
+    }
+    const mergedOptions = {
+        prefix: "",
+        suffix: "",
+        ...options,
+    };
+    // Handle abbreviation (K/M/B/T)
+    let abbreviation = "";
+    if (mergedOptions.abbreviation && number !== 0) {
+        const abbreviations = ["", "K", "M", "B", "T"];
+        const index = Math.floor(Math.log10(Math.abs(number)) / 3);
+        abbreviation = abbreviations[index] ?? "";
+        number = number / Math.pow(10, index * 3);
+    }
+    // Round if needed
+    if (typeof mergedOptions.decimals === "number" ||
+        typeof mergedOptions.significantDigits === "number") {
+        number = round(number, {
+            decimals: mergedOptions.decimals,
+            significantDigits: mergedOptions.significantDigits,
+        });
+    }
+    // Format with thousands separator
+    const regex = /\B(?=(\d{3})+(?!\d))/g;
+    const [integers, decimals] = number.toString().split(".");
+    const formattedIntegers = integers.replace(regex, ",");
+    const formattedNumber = decimals
+        ? `${formattedIntegers}.${decimals}`
+        : formattedIntegers;
+    // Handle dollar sign prefix placement (after minus sign for negative numbers)
+    if (mergedOptions.prefix === "$") {
+        if (formattedNumber.startsWith("-")) {
+            return `-${mergedOptions.prefix}${formattedNumber.slice(1)}${abbreviation}${mergedOptions.suffix}`;
+        }
+        else if (formattedNumber.startsWith("+")) {
+            return `+${mergedOptions.prefix}${formattedNumber.slice(1)}${abbreviation}${mergedOptions.suffix}`;
+        }
+        else {
+            return `${mergedOptions.prefix}${formattedNumber}${abbreviation}${mergedOptions.suffix}`;
+        }
+    }
+    return `${mergedOptions.prefix}${formattedNumber}${abbreviation}${mergedOptions.suffix}`;
+}

package/script/helpers/getCombinations.d.ts

@@ -0,0 +1,3 @@
+declare function getCombinations(x: any, k: any): any;
+export default getCombinations;
+//# sourceMappingURL=getCombinations.d.ts.map

package/script/helpers/getCombinations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCombinations.d.ts","sourceRoot":"","sources":["../../src/helpers/getCombinations.ts"],"names":[],"mappings":"AAGA,iBAAS,eAAe,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAuB5B;AAED,eAAe,eAAe,CAAC"}

package/script/helpers/getCombinations.js

@@ -0,0 +1,26 @@
+"use strict";
+// from https://github.com/simple-statistics/simple-statistics/blob/main/src/combinations.js
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore: Needs to be reworked.
+function getCombinations(x, k) {
+    let i;
+    let subI;
+    const combinationList = [];
+    let subsetCombinations;
+    let next;
+    for (i = 0; i < x.length; i++) {
+        if (k === 1) {
+            combinationList.push([x[i]]);
+        }
+        else {
+            subsetCombinations = getCombinations(x.slice(i + 1, x.length), k - 1);
+            for (subI = 0; subI < subsetCombinations.length; subI++) {
+                next = subsetCombinations[subI];
+                next.unshift(x[i]);
+                combinationList.push(next);
+            }
+        }
+    }
+    return combinationList;
+}
+exports.default = getCombinations;

package/script/helpers/getExtension.d.ts

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

package/script/helpers/getExtension.d.ts.map

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

package/script/helpers/getExtension.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getExtension;
+function getExtension(path) {
+    const extensionSplit = path
+        .replace(".gz", "")
+        .replace(".zstd", "")
+        .split(".");
+    const extension = extensionSplit[extensionSplit.length - 1]
+        .toLocaleLowerCase();
+    return extension;
+}

package/script/helpers/getIdenticalColumns.d.ts

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

package/script/helpers/getIdenticalColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIdenticalColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/getIdenticalColumns.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EAAE,YAGxB"}

package/script/helpers/getIdenticalColumns.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getIdenticalColumns;
+function getIdenticalColumns(table1Columns, table2Columns) {
+    return table1Columns.filter((column) => table2Columns.includes(column));
+}

package/script/helpers/getName.d.ts

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

package/script/helpers/getName.d.ts.map

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

package/script/helpers/getName.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getName;
+function getName(file) {
+    if (file === ":memory:") {
+        return "memory";
+    }
+    else {
+        const nameSplit = file.split("/");
+        const name = nameSplit[nameSplit.length - 1];
+        if (!name.includes(".")) {
+            return name; // Return the name directly if there's no extension
+        }
+        const nameWithoutExtension = name.split(".").slice(0, -1).join(".");
+        return nameWithoutExtension;
+    }
+}

package/script/helpers/getProjection.d.ts

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

package/script/helpers/getProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProjection.d.ts","sourceRoot":"","sources":["../../src/helpers/getProjection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAGjD,wBAA8B,aAAa,CACzC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,mBA8Bb"}

package/script/helpers/getProjection.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getProjection;
+const mergeOptions_js_1 = __importDefault(require("./mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("./queryDB.js"));
+const cleanPath_js_1 = __importDefault(require("./cleanPath.js"));
+async function getProjection(simpleDB, file) {
+    // Load spatial may not be necessary if we change how this works
+    const queryResult = await (0, queryDB_js_1.default)(simpleDB, `INSTALL spatial;
+        LOAD spatial;
+        SELECT layers[1].geometry_fields[1].crs.proj4 as proj4 FROM st_read_meta('${(0, cleanPath_js_1.default)(file)}')`, (0, mergeOptions_js_1.default)(simpleDB, {
+        table: null,
+        method: "getProjection()",
+        parameters: { file },
+        returnDataFrom: "query",
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResults");
+    }
+    const proj4 = queryResult[0].proj4;
+    if (typeof proj4 !== "string") {
+        throw new Error(`Expected proj4 to be a string, got ${typeof proj4}`);
+    }
+    return proj4;
+}

package/script/helpers/getProjectionParquet.d.ts

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

package/script/helpers/getProjectionParquet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProjectionParquet.d.ts","sourceRoot":"","sources":["../../src/helpers/getProjectionParquet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,wBAA8B,oBAAoB,CAChD,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,gBA+Bb"}

package/script/helpers/getProjectionParquet.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 = getProjectionParquet;
+const cleanPath_js_1 = __importDefault(require("./cleanPath.js"));
+const mergeOptions_js_1 = __importDefault(require("./mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("./queryDB.js"));
+async function getProjectionParquet(SimpleTable, file) {
+    const queryResult = await (0, queryDB_js_1.default)(SimpleTable, `SELECT * FROM parquet_kv_metadata('${(0, cleanPath_js_1.default)(file)}');`, (0, mergeOptions_js_1.default)(SimpleTable, {
+        table: SimpleTable.name,
+        method: "getProjectionParquet()",
+        parameters: { file },
+        returnDataFrom: "query",
+    }));
+    if (!queryResult) {
+        throw new Error(`Could not get metadata from parquet file: ${file}`);
+    }
+    const projection = queryResult.find((d) => {
+        return d.key?.toString() === "projections";
+    });
+    if (!projection || projection.value === null) {
+        console.warn(`\nCould not get projection from parquet file: ${file}\n`);
+        return {};
+    }
+    else {
+        return JSON.parse(projection.value.replaceAll("\\x22", '"'));
+    }
+}

package/script/helpers/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Helper utilities for Simple Data Analysis Core.
+ *
+ * These helpers are exported for reuse by `simple-data-analysis` and other
+ * consumers, removing the need to duplicate their implementations.
+ *
+ * @example
+ * ```ts
+ * import { parseValue, stringToArray } from "@nshiab/simple-data-analysis-core/helpers";
+ *
+ * const literal = parseValue("hello");
+ * const arr = stringToArray("single");
+ * ```
+ */
+export { default as createDirectory } from "./createDirectory.js";
+export { default as mergeOptions } from "./mergeOptions.js";
+export { default as parseValue } from "./parseValue.js";
+export { default as queryDB } from "./queryDB.js";
+export { default as stringToArray } from "./stringToArray.js";
+//# sourceMappingURL=index.d.ts.map

package/script/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/script/helpers/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Helper utilities for Simple Data Analysis Core.
+ *
+ * These helpers are exported for reuse by `simple-data-analysis` and other
+ * consumers, removing the need to duplicate their implementations.
+ *
+ * @example
+ * ```ts
+ * import { parseValue, stringToArray } from "@nshiab/simple-data-analysis-core/helpers";
+ *
+ * const literal = parseValue("hello");
+ * const arr = stringToArray("single");
+ * ```
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToArray = exports.queryDB = exports.parseValue = exports.mergeOptions = exports.createDirectory = void 0;
+var createDirectory_js_1 = require("./createDirectory.js");
+Object.defineProperty(exports, "createDirectory", { enumerable: true, get: function () { return __importDefault(createDirectory_js_1).default; } });
+var mergeOptions_js_1 = require("./mergeOptions.js");
+Object.defineProperty(exports, "mergeOptions", { enumerable: true, get: function () { return __importDefault(mergeOptions_js_1).default; } });
+var parseValue_js_1 = require("./parseValue.js");
+Object.defineProperty(exports, "parseValue", { enumerable: true, get: function () { return __importDefault(parseValue_js_1).default; } });
+var queryDB_js_1 = require("./queryDB.js");
+Object.defineProperty(exports, "queryDB", { enumerable: true, get: function () { return __importDefault(queryDB_js_1).default; } });
+var stringToArray_js_1 = require("./stringToArray.js");
+Object.defineProperty(exports, "stringToArray", { enumerable: true, get: function () { return __importDefault(stringToArray_js_1).default; } });

package/script/helpers/keepNumericalColumns.d.ts

@@ -0,0 +1,4 @@
+export default function keepNumericalColumns(types: {
+    [key: string]: string;
+}): string[];
+//# sourceMappingURL=keepNumericalColumns.d.ts.map

package/script/helpers/keepNumericalColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keepNumericalColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/keepNumericalColumns.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,YAc5E"}