@necrolab/dashboard 0.5.21 → 0.5.23

package/src/libs/tm-renderer/dependencies/logger.js

@@ -0,0 +1,186 @@
+function zeroPadding(num, length) {
+    let numAsStr = String(num);
+    while (numAsStr.length < length) {
+        numAsStr = `0${numAsStr}`;
+    }
+    return numAsStr;
+}
+
+function timestamp() {
+    const now = new Date();
+    const hours = zeroPadding(now.getHours(), 2);
+    const minutes = zeroPadding(now.getMinutes(), 2);
+    const seconds = zeroPadding(now.getSeconds(), 2);
+    const milli = zeroPadding(now.getMilliseconds(), 3);
+    return `${hours}:${minutes}:${seconds}.${milli}`;
+}
+
+const ANSI_COLORS = {
+    error: "\x1B[91m",
+    success: "\x1B[92m",
+    info: "\x1B[96m",
+    debug: "\x1B[95m",
+    yellow: "\x1B[93m",
+    reset: "\x1B[0m",
+    timestamp: "\x1B[90m",
+    tag: "\x1B[97m",
+};
+
+const CSS_STYLES = {
+    error: "color: #ff6b6b; font-weight: bold;",
+    success: "color: #51cf66; font-weight: bold;",
+    info: "color: #74c0fc; font-weight: bold;",
+    debug: "color: #da77f2; font-weight: bold;",
+    yellow: "color: #ffd43b; font-weight: bold;",
+    timestamp: "color: #868e96; font-size: 0.9em;",
+    tag: "color: #f8f9fa; font-weight: bold; background: #495057; padding: 2px 6px; border-radius: 3px;",
+};
+
+class NodeLogger {
+    constructor() {
+        this.ENABLED = true;
+        this.defaultArgs = [];
+    }
+
+    _formatMessage(level, ...args) {
+        if (!this.ENABLED) return;
+
+        const color = ANSI_COLORS[level] || ANSI_COLORS.reset;
+        const reset = ANSI_COLORS.reset;
+
+        const timeStr = `${color}[${timestamp()}]${reset}`;
+
+        const tagStrs = this.defaultArgs.map((tag) => `${color}[${tag}]${reset}`);
+
+        const formattedArgs = args.map((arg) => {
+            if (arg instanceof Error) {
+                return arg.stack || arg.toString();
+            } else if (typeof arg === "object" && arg !== null) {
+                try {
+                    return JSON.stringify(arg, null, 2);
+                } catch (e) {
+                    return `[Object: ${arg.constructor?.name || "Unknown"}]`;
+                }
+            }
+            return arg;
+        });
+
+        console.log(timeStr, ...tagStrs, ...formattedArgs);
+    }
+
+    Error(...args) {
+        this._formatMessage("error", ...args);
+    }
+    Success(...args) {
+        this._formatMessage("success", ...args);
+    }
+    Info(...args) {
+        this._formatMessage("info", ...args);
+    }
+    Debug(...args) {
+        this._formatMessage("debug", ...args);
+    }
+    Yellow(...args) {
+        this._formatMessage("yellow", ...args);
+    }
+
+    Disable() {
+        this.ENABLED = false;
+    }
+    Enable() {
+        this.ENABLED = true;
+    }
+}
+
+class BrowserLogger {
+    constructor() {
+        this.ENABLED = true;
+        this.defaultArgs = [];
+    }
+
+    _formatMessage(level, ...args) {
+        if (!this.ENABLED) return;
+
+        const consoleMethod =
+            level === "error" ? "error" : level === "debug" ? "debug" : level === "info" ? "info" : "log";
+
+        const levelStyle = CSS_STYLES[level] || "";
+
+        const timeStr = `%c[${timestamp()}]`;
+        const tagStrs = this.defaultArgs.map((tag) => `%c[${tag}]`);
+
+        const formatStr = [timeStr, ...tagStrs].join(" ");
+
+        const styles = [levelStyle, ...this.defaultArgs.map(() => levelStyle)];
+
+        const formattedArgs = args.map((arg) => {
+            if (arg instanceof Error) {
+                return arg;
+            } else if (typeof arg === "object" && arg !== null) {
+                return arg;
+            }
+            return arg;
+        });
+
+        console[consoleMethod](formatStr, ...styles, ...formattedArgs);
+    }
+
+    Error(...args) {
+        this._formatMessage("error", ...args);
+    }
+    Success(...args) {
+        this._formatMessage("success", ...args);
+    }
+    Info(...args) {
+        this._formatMessage("info", ...args);
+    }
+    Debug(...args) {
+        this._formatMessage("debug", ...args);
+    }
+    Yellow(...args) {
+        this._formatMessage("yellow", ...args);
+    }
+
+    Disable() {
+        this.ENABLED = false;
+    }
+    Enable() {
+        this.ENABLED = true;
+    }
+}
+
+class NoOpLogger {
+    Error() {}
+    Success() {}
+    Info() {}
+    Debug() {}
+    Yellow() {}
+    Disable() {}
+    Enable() {}
+}
+
+function createLogger(args) {
+    let logger;
+
+    if (typeof console === "undefined") {
+        logger = new NoOpLogger();
+    } else if (typeof window !== "undefined") {
+        logger = new BrowserLogger();
+    } else {
+        logger = new NodeLogger();
+    }
+
+    if (typeof args === "string") {
+        logger.defaultArgs = [args];
+    } else if (Array.isArray(args)) {
+        logger.defaultArgs = args.filter((arg) => typeof arg === "string");
+    } else if (args) {
+        logger.defaultArgs = [String(args)];
+    } else {
+        logger.defaultArgs = [];
+    }
+
+    return logger;
+}
+
+export { createLogger };

package/src/libs/tm-renderer/dependencies/node.persist.js

@@ -0,0 +1,100 @@
+import { createLogger } from "./logger.js";
+import { sleep } from "../utils.js";
+
+// eslint-disable-next-line no-unused-vars
+const logger = createLogger("TM-RENDERER");
+
+class NodePersistProxy {
+    constructor(db) {
+        this.db = db;
+        this.retryLimit = 3;
+        this.sleepTime = 1000;
+    }
+
+    async init(options) {
+        logger.Success("Initialized local DB");
+        return this.db.init(options);
+    }
+
+    async keys(retries = 0) {
+        if (retries == this.retryLimt) return;
+
+        try {
+            return this.db.keys().catch((ex) => {
+                throw ex;
+            });
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .keys() (${ex.message})`);
+            await sleep(this.sleepTime);
+            return this.keys(++retries);
+        }
+    }
+
+    async getItem(key, retries = 0) {
+        if (!key) return;
+        if (retries == this.retryLimt) return;
+
+        try {
+            return this.db.getItem(key).catch(() => {});
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .getItem() (${ex.message})`);
+            await sleep(this.sleepTime);
+            return this.getItem(key, ++retries);
+        }
+    }
+
+    async getMultiple(keys, retries = 0) {
+        if (!keys) return;
+        if (retries == this.retryLimt) return;
+
+        try {
+            const results = [];
+            for (let i = 0; i < keys.length; i++) {
+                results.push(await this.getItem(keys[i]));
+            }
+            return results;
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .getMultiple() (${ex.message})`);
+            await sleep(this.sleepTime);
+            return this.getMultiple(keys, ++retries);
+        }
+    }
+
+    async setItem(key, value, retries = 0) {
+        if (retries == this.retryLimt) return;
+
+        try {
+            return this.db.setItem(key, value).catch(() => {});
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .setItem() (${ex.message})`);
+            await sleep(this.sleepTime);
+            return this.setItem(key, value, ++retries);
+        }
+    }
+
+    async removeItem(key, retries = 0) {
+        if (retries == this.retryLimt) return;
+
+        try {
+            return this.db.removeItem(key).catch(() => {});
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .removeItem() (${ex.message})`);
+            await sleep(this.sleepTime);
+            return this.removeItem(key, ++retries);
+        }
+    }
+
+    async updateItem(key, value, opts = {}, retries = 0) {
+        if (retries == this.retryLimt) return;
+
+        try {
+            return this.db.updateItem(key, value, opts).catch(() => {});
+        } catch (ex) {
+            logger.Error(`PERSIST: Retrying .updateItem() (${ex.message})`, key, value);
+            await sleep(this.sleepTime);
+            return this.updateItem(key, opts, value, ++retries);
+        }
+    }
+}
+
+export default NodePersistProxy;

package/src/libs/tm-renderer/dependencies/persist.js

@@ -0,0 +1,23 @@
+import { createLogger } from "./logger.js";
+import NodePersistance from "./node.persist.js";
+
+const logger = createLogger("TM-RENDERER");
+
+export default async () => {
+    logger.Info("Using node-persist");
+    const path = await import("node:path");
+    const os = await import("node:os");
+    const storage = await import("node-persist");
+    const fullPath = `${os.homedir()}/.renderer-store/`;
+    const p = path.relative(process.cwd(), fullPath);
+
+    let storageProxy = new NodePersistance(storage);
+    await storageProxy.init({
+        forgiveParseErrors: true,
+        writeQueue: true,
+        writeQueueIntervalMs: 1000,
+        writeQueueWriteOnlyLast: true,
+        dir: p,
+    });
+    return storageProxy;
+};

package/src/libs/tm-renderer/dependencies/web.persist.js

@@ -0,0 +1,64 @@
+class WebPersistance {
+    constructor() {
+        this.useLocalStorage = typeof localStorage !== "undefined";
+        if (!this.useLocalStorage) {
+            this.storage = new Map();
+        }
+    }
+
+    setItem(key, value) {
+        try {
+            if (this.useLocalStorage) {
+                localStorage.setItem(key, JSON.stringify(value));
+            } else {
+                this.storage.set(key, value);
+            }
+            return value;
+        } catch (e) {
+            if (this.useLocalStorage && !this.storage) {
+                this.storage = new Map();
+                this.useLocalStorage = false;
+            }
+            if (this.storage) {
+                this.storage.set(key, value);
+            }
+            return value;
+        }
+    }
+
+    getItem(key) {
+        try {
+            if (this.useLocalStorage) {
+                const item = localStorage.getItem(key);
+                return item ? JSON.parse(item) : undefined;
+            } else {
+                return this.storage.get(key);
+            }
+        } catch (e) {
+            if (this.useLocalStorage && !this.storage) {
+                this.storage = new Map();
+                this.useLocalStorage = false;
+            }
+            return this.storage ? this.storage.get(key) : undefined;
+        }
+    }
+
+    removeItem(key) {
+        try {
+            if (this.useLocalStorage) {
+                localStorage.removeItem(key);
+                return true;
+            } else {
+                return this.storage.delete(key);
+            }
+        } catch (e) {
+            if (this.useLocalStorage && !this.storage) {
+                this.storage = new Map();
+                this.useLocalStorage = false;
+            }
+            return this.storage ? this.storage.delete(key) : false;
+        }
+    }
+}
+
+export default WebPersistance;

package/src/libs/tm-renderer/factory.js

@@ -0,0 +1,47 @@
+import TMRenderer from "./tm/renderer.js";
+import AXSRenderer from "./axs/renderer.js";
+import { createLogger } from "./dependencies/logger.js";
+
+class RendererFactory {
+    constructor() {
+        this.logger = createLogger("RENDERER-FACTORY");
+    }
+    async init() {
+        // Browser-only version - always use WebPersistance
+        const { default: WebPersistance } = await import("./dependencies/web.persist.js");
+        this.storage = new WebPersistance();
+        this.logger.Info("Renderer initialized for browser");
+    }
+
+    createRenderer(eventId, options = {}) {
+        if (!this.storage) {
+            this.logger.Error("RendererFactory used before initialization");
+            return null;
+        }
+
+        const renderer = new TMRenderer(eventId, options);
+        renderer.init({
+            storage: this.storage,
+            sharp: this.sharp,
+            fs: this.fs,
+        });
+        return renderer;
+    }
+
+    createAXSRenderer(eventId, options = {}) {
+        if (!this.storage) {
+            this.logger.Error("RendererFactory used before initialization");
+            return null;
+        }
+
+        const renderer = new AXSRenderer(eventId, options);
+        renderer.init({
+            storage: this.storage,
+            sharp: this.sharp,
+            fs: this.fs,
+        });
+        return renderer;
+    }
+}
+
+export default RendererFactory;

package/src/libs/tm-renderer/index.js

@@ -0,0 +1,21 @@
+import RendererFactory from "./factory.js";
+
+if (typeof process !== "undefined" && process.env) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+
+    if (process.removeAllListeners) {
+        process.removeAllListeners("warning");
+    }
+
+    if (process.emitWarning) {
+        const originalEmitWarning = process.emitWarning;
+        process.emitWarning = function (warning, type, code, ctor) {
+            const suppressedTypes = ["ExperimentalWarning", "DeprecationWarning", "UnhandledPromiseRejectionWarning"];
+            if (suppressedTypes.includes(type)) return;
+
+            return originalEmitWarning.call(process, warning, type, code, ctor);
+        };
+    }
+}
+
+export default RendererFactory;

package/src/libs/tm-renderer/request-utils.js

@@ -0,0 +1,101 @@
+import { sleep } from "./utils.js";
+
+const device = {
+    "user-agent":
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
+    "sec-ch-ua": `"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"`,
+    "sec-ch-ua-platform": '"macOS"',
+};
+
+const headers = {
+    "sec-ch-ua": device["sec-ch-ua"],
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": device["sec-ch-ua-platform"],
+    "dnt": "1",
+    "user-agent": device["user-agent"],
+    "sec-fetch-site": "none",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-user": "?1",
+    "sec-fetch-dest": "document",
+    "accept-encoding": "gzip, deflate, br, zstd",
+    "accept-language": "en-US,en;q=0.9",
+};
+
+async function createProxyAgent(proxy) {
+    // Browser-only version - no proxy support
+    return undefined;
+}
+
+async function getFetchOptions(targetUrl, proxy = null, customHeaders = {}) {
+    // Browser-only version with minimal headers for maximum compatibility
+    const options = {
+        headers: {
+            ...customHeaders,
+        },
+        mode: "cors",
+        cache: "default"
+    };
+
+    return options;
+}
+
+async function makeRequest(url, options = {}, retries = 0, logger = null) {
+    try {
+        const response = await fetch(url, options);
+
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        return response;
+    } catch (error) {
+        if (logger) {
+            logger.Error(`Request failed (${retries + 1}/3): ${error.message}`);
+        }
+
+        if (retries >= 2) {
+            throw error;
+        }
+
+        await sleep(1000);
+        return makeRequest(url, options, retries + 1, logger);
+    }
+}
+
+async function getJsonData(url, options = {}, retries = 0, logger = null) {
+    const response = await makeRequest(url, options, retries, logger);
+    return await response.json();
+}
+
+async function getBinaryData(url, options = {}, retries = 0, logger = null) {
+    const response = await makeRequest(url, options, retries, logger);
+    const arrayBuffer = await response.arrayBuffer();
+
+    // Use Buffer in Node.js, Uint8Array in browser
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(arrayBuffer);
+    }
+    return new Uint8Array(arrayBuffer);
+}
+
+async function getJsonDataWithHeaders(url, customHeaders = {}, proxy = null, retries = 0, logger = null) {
+    const options = await getFetchOptions(url, proxy, customHeaders);
+    return await getJsonData(url, options, retries, logger);
+}
+
+async function getBinaryDataWithHeaders(url, customHeaders = {}, proxy = null, retries = 0, logger = null) {
+    const options = await getFetchOptions(url, proxy, customHeaders);
+    return await getBinaryData(url, options, retries, logger);
+}
+
+export {
+    createProxyAgent,
+    getFetchOptions,
+    makeRequest,
+    getJsonData,
+    getBinaryData,
+    getJsonDataWithHeaders,
+    getBinaryDataWithHeaders,
+    headers,
+    device,
+};