@kidus.dev/flowdb 1.0.0

package/dist/core/store/store_file_driver.d.ts

@@ -0,0 +1,26 @@
+type AnyObject = {
+    [key: string]: any;
+};
+export default class StoreFileStorage {
+    private readonly _encrypted;
+    private readonly _file;
+    private readonly _encryptor;
+    constructor({ path, encrypted, secretKey, }: {
+        path: string;
+        encrypted?: boolean;
+        secretKey?: string;
+    });
+    create(): void;
+    delete(): void;
+    get size(): number;
+    readAll(): Record<string, any>;
+    writeAll(data: AnyObject): void;
+    set(key: string, value: any): any;
+    setFrom(key: string, func: (data: any) => any, fallback?: any): any;
+    get(key: string): any;
+    remove(key: string): AnyObject;
+    has(key: string): boolean;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=store_file_driver.d.ts.map

package/dist/core/store/store_file_driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store_file_driver.d.ts","sourceRoot":"","sources":["../../../src/core/store/store_file_driver.ts"],"names":[],"mappings":"AAIA,KAAK,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC;AAExC,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;gBAE3B,EACV,IAAI,EACJ,SAAS,EACT,SAAS,GACV,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;IAMD,MAAM;IAUN,MAAM;IAMN,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAc9B,QAAQ,CAAC,IAAI,EAAE,SAAS;IAMxB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IASjC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,GAAG;IASnE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAS9B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,KAAK;CAGN"}

package/dist/core/store/store_file_driver.js

@@ -0,0 +1,87 @@
+import * as fs from "fs";
+import * as path from "path";
+import { Encryptor, Json } from "../../tools";
+export default class StoreFileStorage {
+    _encrypted;
+    _file;
+    _encryptor;
+    constructor({ path, encrypted, secretKey, }) {
+        this._file = path;
+        this._encrypted = encrypted ?? false;
+        this._encryptor = new Encryptor({ round: 10, key: secretKey });
+    }
+    create() {
+        const dir = path.dirname(this._file);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        if (!fs.existsSync(this._file)) {
+            fs.writeFileSync(this._file, "");
+        }
+    }
+    delete() {
+        if (fs.existsSync(this._file)) {
+            fs.unlinkSync(this._file);
+        }
+    }
+    get size() {
+        if (fs.existsSync(this._file)) {
+            return fs.statSync(this._file).size;
+        }
+        return 0;
+    }
+    readAll() {
+        if (!fs.existsSync(this._file))
+            return {};
+        const fileContents = fs.readFileSync(this._file, "utf-8");
+        const content = this._encrypted
+            ? this._encryptor.dec(fileContents)
+            : fileContents;
+        if (!content || content.trim().length === 0)
+            return {};
+        try {
+            return Json.parse(content);
+        }
+        catch {
+            return {};
+        }
+    }
+    writeAll(data) {
+        const jsonData = Json.stringify(data);
+        const content = this._encrypted ? this._encryptor.enc(jsonData) : jsonData;
+        fs.writeFileSync(this._file, content);
+    }
+    set(key, value) {
+        const content = this.readAll();
+        const updated = Json.update(content, key, value);
+        if (JSON.stringify(updated) !== JSON.stringify(content)) {
+            this.writeAll(updated);
+        }
+        return value;
+    }
+    setFrom(key, func, fallback) {
+        const content = this.readAll();
+        const oldData = Json.getNested(content, key);
+        const newValue = func(oldData !== undefined ? oldData : fallback);
+        const updated = Json.update(content, key, newValue);
+        this.writeAll(updated);
+        return newValue;
+    }
+    get(key) {
+        return Json.getNested(this.readAll(), key);
+    }
+    remove(key) {
+        const content = this.readAll();
+        const updated = Json.remove(content, key);
+        if (JSON.stringify(updated) !== JSON.stringify(content)) {
+            this.writeAll(updated);
+        }
+        return updated;
+    }
+    has(key) {
+        return Json.getNested(this.readAll(), key) !== undefined;
+    }
+    clear() {
+        this.writeAll({});
+    }
+}

package/dist/tools/encryptor.d.ts

@@ -0,0 +1,17 @@
+export default class Encryptor {
+    private _key;
+    private _round;
+    private static readonly _defaultKey;
+    constructor({ key, round }?: {
+        key?: string;
+        round?: number;
+    });
+    enc(data: string): string;
+    dec(data: string): string;
+    static encrypt(data: string, key?: string, round?: number): string;
+    static decrypt(encryptedData: string, key?: string, round?: number): string;
+    private static _deriveKey;
+    private static _encryptBytes;
+    private static _decryptBytes;
+}
+//# sourceMappingURL=encryptor.d.ts.map

package/dist/tools/encryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryptor.d.ts","sourceRoot":"","sources":["../../src/tools/encryptor.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAsC;gBAE7D,EAAE,GAAG,EAAE,KAAK,EAAE,GAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO;IAKjE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIzB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIzB,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAAe,GAAG,MAAM;IAW1E,MAAM,CAAC,OAAO,CACZ,aAAa,EAAE,MAAM,EACrB,GAAG,CAAC,EAAE,MAAM,EACZ,KAAK,GAAE,MAAe,GACrB,MAAM;IAwBT,OAAO,CAAC,MAAM,CAAC,UAAU;IAazB,OAAO,CAAC,MAAM,CAAC,aAAa;IAc5B,OAAO,CAAC,MAAM,CAAC,aAAa;CAiB7B"}

package/dist/tools/encryptor.js

@@ -0,0 +1,80 @@
+import * as crypto from "crypto";
+export default class Encryptor {
+    _key;
+    _round;
+    static _defaultKey = "535d260689feff3b45afb004190505ab";
+    constructor({ key, round } = {}) {
+        this._key = key ?? Encryptor._defaultKey;
+        this._round = round ?? 10_000;
+    }
+    enc(data) {
+        return Encryptor.encrypt(data, this._key, this._round);
+    }
+    dec(data) {
+        return Encryptor.decrypt(data, this._key, this._round);
+    }
+    static encrypt(data, key, round = 10_000) {
+        const encryptionKey = key ?? Encryptor._defaultKey;
+        const keyBytes = Buffer.from(encryptionKey, "utf8");
+        const dataBytes = Buffer.from(data, "utf8");
+        const iv = crypto.randomBytes(16);
+        const derivedKey = Encryptor._deriveKey(keyBytes, iv, round);
+        const encryptedBytes = Encryptor._encryptBytes(dataBytes, derivedKey, iv);
+        const combined = Buffer.concat([iv, encryptedBytes]);
+        return combined.toString("base64");
+    }
+    static decrypt(encryptedData, key, round = 10_000) {
+        try {
+            const encryptionKey = key ?? Encryptor._defaultKey;
+            const keyBytes = Buffer.from(encryptionKey, "utf8");
+            const combined = Buffer.from(encryptedData, "base64");
+            if (combined.length < 16)
+                return "";
+            const iv = combined.subarray(0, 16);
+            const encryptedBytes = combined.subarray(16);
+            const derivedKey = Encryptor._deriveKey(keyBytes, iv, round);
+            const decryptedBytes = Encryptor._decryptBytes(encryptedBytes, derivedKey, iv);
+            return Buffer.from(decryptedBytes).toString("utf8");
+        }
+        catch (e) {
+            throw new Error(`Error decrypting data: ${e}, May be the key is incorrect or the data is corrupted`);
+        }
+    }
+    // Derive a key from a key and a salt
+    static _deriveKey(key, salt, round) {
+        let derivedKey = crypto.createHmac("sha256", key).update(salt).digest();
+        for (let i = 0; i < round; i++) {
+            derivedKey = crypto
+                .createHmac("sha256", derivedKey)
+                .update(derivedKey)
+                .digest();
+        }
+        return derivedKey;
+    }
+    static _encryptBytes(data, key, iv) {
+        const result = Buffer.alloc(data.length);
+        for (let i = 0; i < data.length; i++) {
+            const keyByte = key[i % key.length];
+            const ivByte = iv[i % iv.length];
+            const dataByte = data[i];
+            let encrypted = dataByte ^ keyByte ^ ivByte;
+            encrypted = ((encrypted << 3) | (encrypted >> 5)) & 0xff;
+            encrypted = encrypted ^ ((keyByte + ivByte) % 256);
+            result[i] = encrypted;
+        }
+        return result;
+    }
+    static _decryptBytes(encryptedData, key, iv) {
+        const result = Buffer.alloc(encryptedData.length);
+        for (let i = 0; i < encryptedData.length; i++) {
+            const keyByte = key[i % key.length];
+            const ivByte = iv[i % iv.length];
+            const encryptedByte = encryptedData[i];
+            let decrypted = encryptedByte ^ ((keyByte + ivByte) % 256);
+            decrypted = ((decrypted >> 3) | (decrypted << 5)) & 0xff;
+            decrypted = decrypted ^ keyByte ^ ivByte;
+            result[i] = decrypted;
+        }
+        return result;
+    }
+}

package/dist/tools/format.d.ts

@@ -0,0 +1,10 @@
+export default class Format {
+    static suffixes: string[];
+    static dateToYMD(date: Date): string;
+    static dateToYMDHMS(date: Date): string;
+    static dateToHMS(date: Date): string;
+    static sizeToHumanReadable(size: number): string;
+    static durationToHumanReadable(duration: number): string;
+    static numberToHumanReadable(number: number): string;
+}
+//# sourceMappingURL=format.d.ts.map

package/dist/tools/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/tools/format.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,MAAM,CAAC,QAAQ,WAAyD;IACxE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIpC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIvC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIpC,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAehD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAUxD,MAAM,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAQrD"}

package/dist/tools/format.js

@@ -0,0 +1,40 @@
+export default class Format {
+    static suffixes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    static dateToYMD(date) {
+        return date.toISOString().split("T")[0];
+    }
+    static dateToYMDHMS(date) {
+        return date.toISOString().replace("T", " ").split(".")[0];
+    }
+    static dateToHMS(date) {
+        return date.toISOString().split("T")[1].split(".")[0];
+    }
+    static sizeToHumanReadable(size) {
+        const suffixes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+        if (size <= 0 || isNaN(size))
+            return "0 B";
+        let i = size > 0 ? Math.floor(Math.log(size) / Math.log(1024)) : 0;
+        i = Math.max(0, Math.min(i, suffixes.length - 1));
+        const displaySize = size / Math.pow(1024, i);
+        if (!isFinite(displaySize) || isNaN(displaySize)) {
+            return "0 B";
+        }
+        return `${displaySize.toFixed(2)} ${suffixes[i]}`;
+    }
+    static durationToHumanReadable(duration) {
+        // duration is assumed to be in milliseconds
+        const microseconds = duration * 1000;
+        const milliseconds = duration;
+        const seconds = duration / 1000;
+        const minutes = duration / (1000 * 60);
+        return `[ ${microseconds} µs | ${milliseconds} ms | ${seconds} s | ${minutes} mn ]`;
+    }
+    static numberToHumanReadable(number) {
+        let s = number.toFixed(2);
+        // Add commas for thousands
+        s = s.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        // Remove ".00" at end if present
+        s = s.replace(/\.00$/, "");
+        return s;
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Json } from "./json";
+export { default as Random } from "./random";
+export { default as Format } from "./format";
+export { default as PrintColored } from "./print_colored";
+export { default as Encryptor } from "./encryptor";
+export { default as Performance } from "./performance";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+export { default as Json } from "./json";
+export { default as Random } from "./random";
+export { default as Format } from "./format";
+export { default as PrintColored } from "./print_colored";
+export { default as Encryptor } from "./encryptor";
+export { default as Performance } from "./performance";

package/dist/tools/json.d.ts

@@ -0,0 +1,19 @@
+type JsonObject = {
+    [key: string]: any;
+};
+export default class Json {
+    static isNull(v: string): boolean;
+    static isNumber(v: string): boolean;
+    static isDouble(v: string): boolean;
+    static isBoolean(v: string): boolean;
+    static isDate(v: string): boolean;
+    static isMap(v: string): boolean;
+    static parse(value: string): any;
+    static stringify(map: JsonObject): string;
+    static update(json: Record<string, any>, path: string, newValue: any): any;
+    static getNested(input: any, path: string): any;
+    static remove(input: any, path: string): any;
+    static mapToCSV(rows: JsonObject[]): string;
+}
+export {};
+//# sourceMappingURL=json.d.ts.map

package/dist/tools/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/tools/json.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAIjC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAInC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAInC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAIpC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAKjC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAIhC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG;IAuDhC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IA2BzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,GAAG;IAyC1E,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG;IAoC/C,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG;IA4C5C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM;CAkB5C"}

package/dist/tools/json.js

@@ -0,0 +1,232 @@
+export default class Json {
+    static isNull(v) {
+        return v === "null" || v === "" || v === undefined || v === null;
+    }
+    static isNumber(v) {
+        return /^-?\d+$/.test(v);
+    }
+    static isDouble(v) {
+        return /^-?\d*\.\d+(e[+-]?\d+)?$/i.test(v);
+    }
+    static isBoolean(v) {
+        return v === "true" || v === "false";
+    }
+    static isDate(v) {
+        return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})?$/.test(v);
+    }
+    static isMap(v) {
+        return /^\s*{[\s\S]*}\s*$/.test(v);
+    }
+    static parse(value) {
+        if (typeof value === "string") {
+            const v = value.trim();
+            if (Json.isNull(v))
+                return null;
+            if (Json.isNumber(v))
+                return parseInt(v, 10);
+            if (Json.isDouble(v))
+                return parseFloat(v);
+            if (Json.isBoolean(v.toLowerCase()))
+                return v.toLowerCase() === "true";
+            if (Json.isDate(v)) {
+                const d = new Date(v);
+                if (!isNaN(d.valueOf()))
+                    return d;
+            }
+            if (Json.isMap(v)) {
+                try {
+                    let quoted = v;
+                    quoted = quoted.replace(/([,{]\s*)([A-Za-z0-9_]+)\s*:/g, '$1"$2":');
+                    quoted = quoted.replace(/:\s*([A-Za-z_][A-Za-z0-9_\s]*)/g, (m, val) => {
+                        val = val.trim();
+                        if (Json.isNumber(val) ||
+                            Json.isDouble(val) ||
+                            Json.isBoolean(val) ||
+                            Json.isNull(val)) {
+                            return ": " + val;
+                        }
+                        if (val.startsWith('"') || val.startsWith("'"))
+                            return ": " + val.replace(/^'/, '"').replace(/'$/, '"');
+                        return ': "' + val.replace(/"/g, '\\"') + '"';
+                    });
+                    const jsonObj = JSON.parse(quoted);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    // @ts-ignore
+                    function convert(obj) {
+                        if (Array.isArray(obj))
+                            return obj.map(convert);
+                        if (obj && typeof obj === "object") {
+                            let result = {};
+                            for (let k in obj)
+                                result[k] = convert(obj[k]);
+                            return result;
+                        }
+                        if (typeof obj === "string")
+                            return Json.parse(obj);
+                        return obj;
+                    }
+                    return convert(jsonObj);
+                }
+                catch (_) { }
+            }
+            return value;
+        }
+        return value;
+    }
+    static stringify(map) {
+        function encodeValue(value) {
+            if (value == null || value === undefined) {
+                return "null";
+            }
+            else if (typeof value === "number" || typeof value === "boolean") {
+                return value.toString();
+            }
+            else if (value instanceof Date) {
+                return `"${value.toISOString()}"`;
+            }
+            else if (Array.isArray(value)) {
+                return "[" + value.map(encodeValue).join(", ") + "]";
+            }
+            else if (typeof value === "object" && value !== null) {
+                return Json.stringify(value);
+            }
+            else {
+                let str = value.toString().replace(/"/g, '\\"');
+                return `"${str}"`;
+            }
+        }
+        return ("{" +
+            Object.entries(map)
+                .map(([key, val]) => `"${key}": ${encodeValue(val)}`)
+                .join(", ") +
+            "}");
+    }
+    static update(json, path, newValue) {
+        json = json || {};
+        if (!path)
+            return newValue;
+        const parts = path.split(".");
+        if (!parts.length)
+            return newValue;
+        const key = parts[0];
+        if (!key)
+            return newValue;
+        const restPath = parts.slice(1).join(".");
+        const index = /^[0-9]+$/.test(key) ? parseInt(key, 10) : undefined;
+        // Map/object case (or create a map)
+        if (index === undefined) {
+            let updated = typeof json === "object" && json !== null ? { ...json } : {};
+            if (!restPath) {
+                updated[key] = newValue;
+                return updated;
+            }
+            updated[key] = Json.update(updated.hasOwnProperty(key) ? updated[key] : null, restPath, newValue);
+            return updated;
+        }
+        // List/array case
+        else if (index >= 0) {
+            let list = Array.isArray(json) ? [...json] : [];
+            while (list.length <= index)
+                list.push(null);
+            if (!restPath) {
+                list[index] = newValue;
+                return list;
+            }
+            list[index] = Json.update(list[index], restPath, newValue);
+            return list;
+        }
+        return json;
+    }
+    static getNested(input, path) {
+        if (!path)
+            return input;
+        const parts = path.split(".");
+        if (!parts.length)
+            return input;
+        const key = parts[0];
+        if (!key)
+            return null;
+        const restPath = parts.slice(1).join(".");
+        const index = /^[0-9]+$/.test(key) ? parseInt(key, 10) : undefined;
+        if (input == null)
+            return null;
+        // Map/object case
+        if (typeof input === "object" &&
+            !Array.isArray(input) &&
+            index === undefined) {
+            if (!(key in input))
+                return null;
+            return restPath ? Json.getNested(input[key], restPath) : input[key];
+        }
+        // List/array case
+        else if (Array.isArray(input) &&
+            index !== undefined &&
+            index >= 0 &&
+            index < input.length) {
+            return restPath ? Json.getNested(input[index], restPath) : input[index];
+        }
+        return null; // leaf or invalid
+    }
+    static remove(input, path) {
+        if (!path)
+            return input;
+        const parts = path.split(".");
+        if (!parts.length)
+            return input;
+        const key = parts[0];
+        const restPath = parts.slice(1).join(".");
+        if (input == null)
+            return input;
+        const index = /^[0-9]+$/.test(key ?? "")
+            ? parseInt(key ?? "", 10)
+            : undefined;
+        if (!key)
+            return null;
+        // Map/object
+        if (typeof input === "object" && !Array.isArray(input) && key in input) {
+            if (!restPath) {
+                let copy = { ...input };
+                delete copy[key];
+                return copy;
+            }
+            let copy = { ...input };
+            copy[key] = Json.remove(copy[key], restPath);
+            return copy;
+        }
+        // List/array
+        if (Array.isArray(input) &&
+            index !== undefined &&
+            index >= 0 &&
+            index < input.length) {
+            let copy = [...input];
+            if (!restPath) {
+                copy.splice(index, 1);
+                return copy;
+            }
+            copy[index] = Json.remove(copy[index], restPath);
+            return copy;
+        }
+        return input;
+    }
+    // Map to CSV
+    static mapToCSV(rows) {
+        if (!rows.length)
+            return "";
+        if (!rows[0])
+            return "";
+        const headers = Object.keys(rows[0]);
+        const csvRows = rows.map((row) => headers
+            .map((k) => {
+            let cell = row[k];
+            if (cell == null)
+                return "";
+            if (cell instanceof Date)
+                return cell.toISOString();
+            if (typeof cell === "object")
+                return JSON.stringify(cell);
+            return String(cell).replace(/"/g, '""');
+        })
+            .join(","));
+        return headers.join(",") + "\n" + csvRows.join("\n");
+    }
+}

package/dist/tools/performance.d.ts

@@ -0,0 +1,20 @@
+export type PerformanceResult<T> = {
+    name: string;
+    duration: number;
+    durationFormatted: string;
+    data: T;
+};
+export default class Performance {
+    private stopwatchStart;
+    private stopwatchEnd;
+    readonly name: string;
+    constructor(name: string);
+    static test<T>(name: string, func: () => Promise<T> | T): Promise<PerformanceResult<T>>;
+    start(): void;
+    stop(): void;
+    printIt(): void;
+    get duration(): number;
+    get durationFormatted(): string;
+    toString(): string;
+}
+//# sourceMappingURL=performance.d.ts.map

package/dist/tools/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../src/tools/performance.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC;CACT,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,WAAW;IAC9B,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,YAAY,CAAuB;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM;WAIX,IAAI,CAAC,CAAC,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACzB,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAgBhC,KAAK,IAAI,IAAI;IAKb,IAAI,IAAI,IAAI;IAMZ,OAAO,IAAI,IAAI;IAIf,IAAI,QAAQ,IAAI,MAAM,CAQrB;IAED,IAAI,iBAAiB,IAAI,MAAM,CAO9B;IAED,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/tools/performance.js

@@ -0,0 +1,53 @@
+export default class Performance {
+    stopwatchStart = null;
+    stopwatchEnd = null;
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    static async test(name, func) {
+        const performance = new Performance(name);
+        performance.start();
+        const result = await func();
+        performance.stop();
+        performance.printIt();
+        return {
+            name,
+            duration: performance.duration,
+            durationFormatted: performance.durationFormatted,
+            data: result,
+        };
+    }
+    start() {
+        this.stopwatchStart = Date.now();
+        this.stopwatchEnd = null;
+    }
+    stop() {
+        if (this.stopwatchStart !== null) {
+            this.stopwatchEnd = Date.now();
+        }
+    }
+    printIt() {
+        console.log(this.durationFormatted);
+    }
+    get duration() {
+        if (this.stopwatchStart !== null && this.stopwatchEnd !== null) {
+            return this.stopwatchEnd - this.stopwatchStart;
+        }
+        if (this.stopwatchStart !== null && this.stopwatchEnd === null) {
+            return Date.now() - this.stopwatchStart;
+        }
+        return 0;
+    }
+    get durationFormatted() {
+        const durationMs = this.duration;
+        const microseconds = durationMs * 1000;
+        const milliseconds = durationMs;
+        const seconds = durationMs / 1000;
+        const minutes = seconds / 60;
+        return `${this.name} [${microseconds.toFixed(0)} µs | ${milliseconds.toFixed(0)} ms | ${seconds.toFixed(3)} s | ${minutes.toFixed(2)} mn]`;
+    }
+    toString() {
+        return this.durationFormatted;
+    }
+}