@paroicms/ui-logger 1.12.0

package/README.md

@@ -0,0 +1,9 @@
+# @paroicms/ui-logger
+
+Logger for the BO front of a Paroi CMS.
+
+This package is part of [ParoiCMS](https://www.npmjs.com/package/@paroicms/server).
+
+## License
+
+Released under the [MIT license](https://gitlab.com/paroi/opensource/paroicms/-/blob/main/LICENSE.md).

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { type FullUiLogger, type UiLogger } from "./ui-logger.js";
+export * from "./ui-logger.js";
+export declare const UiLoggerProvider: import("react").Provider<FullUiLogger>;
+export declare function useUiLogger(): UiLogger;

package/dist/index.js

@@ -0,0 +1,8 @@
+import { createContext, useContext } from "react";
+import { createNoUiLogger } from "./ui-logger.js";
+export * from "./ui-logger.js";
+const UiLoggerContext = createContext(createNoUiLogger());
+export const UiLoggerProvider = UiLoggerContext.Provider;
+export function useUiLogger() {
+    return useContext(UiLoggerContext);
+}

package/dist/ui-logger.d.ts

@@ -0,0 +1,36 @@
+export interface UiLogger {
+    error: LogFn;
+    warn: LogFn;
+    info: LogFn;
+    trace: LogFn;
+    debug: LogFn;
+    log(options: LogParameters): void;
+}
+export interface FullUiLogger extends UiLogger {
+    wrapAsync: WrapAsync;
+    lateSetup(options: Partial<UiLoggerOptions>): void;
+}
+export interface LogParameters {
+    level: UiLoggerStrictLevels;
+    message: any[];
+    clientOnly?: boolean;
+}
+export type LogFn = (...messages: any[]) => void;
+export type UiLoggerStrictLevels = Exclude<keyof UiLogger, "log" | "wrapAsync">;
+export type UiLoggerLevels = UiLoggerStrictLevels | "none";
+export interface UiLoggerOptions {
+    minLevel?: UiLoggerLevels;
+    send?: SendToServerOptions;
+}
+export interface SendToServerOptions {
+    minLevel?: UiLoggerLevels;
+    sendToServer?(lines: FrontLogLine[]): Promise<void>;
+}
+export interface FrontLogLine {
+    message: string[];
+    level: UiLoggerStrictLevels;
+}
+export declare function createNoUiLogger(): FullUiLogger;
+export declare function createUiLogger(mainOptions?: UiLoggerOptions): FullUiLogger;
+type WrapAsync = <T extends (...args: any[]) => Promise<any>>(fn: T) => (...args: Parameters<T>) => void;
+export {};

package/dist/ui-logger.js

@@ -0,0 +1,192 @@
+const noOp = () => {
+    // Nothing to do.
+};
+export function createNoUiLogger() {
+    return {
+        error: noOp,
+        warn: noOp,
+        info: noOp,
+        trace: noOp,
+        debug: noOp,
+        log: noOp,
+        wrapAsync: makeWrapAsync({ error: noOp }),
+        lateSetup: () => {
+            throw new Error("'lateSetup' can't be called on noUiLogger.");
+        },
+    };
+}
+export function createUiLogger(mainOptions) {
+    let minLevel = mainOptions?.minLevel ?? "none";
+    let consoleLog = makeToConsole(minLevel);
+    const obj = {
+        ...(mainOptions?.send ? makeToServer(mainOptions.send, consoleLog) : consoleLog),
+        log(options) {
+            if (options.clientOnly) {
+                consoleLog[options.level](...options.message);
+            }
+            else {
+                obj[options.level](...options.message);
+            }
+        },
+        lateSetup(lateOptions) {
+            if (lateOptions.minLevel && lateOptions.minLevel !== minLevel) {
+                minLevel = lateOptions.minLevel;
+                consoleLog = makeToConsole(lateOptions.minLevel);
+            }
+            Object.assign(obj, lateOptions.send ? makeToServer(lateOptions.send, consoleLog) : consoleLog);
+        },
+        get wrapAsync() {
+            return makeWrapAsync(obj);
+        },
+    };
+    return obj;
+}
+function makeToConsole(minLevel) {
+    return {
+        error: toConsole("error", minLevel),
+        warn: toConsole("warn", minLevel),
+        info: toConsole("info", minLevel),
+        trace: toConsole("trace", minLevel),
+        debug: toConsole("debug", minLevel),
+    };
+}
+function toConsole(level, minLevel) {
+    if (!window.console || toLevelNum(level) > toLevelNum(minLevel)) {
+        return () => {
+            // Nothing to do.
+        };
+    }
+    if (console[level]) {
+        return (...messages) => console[level](`[${level}]`, ...messages);
+    }
+    if (console.log) {
+        return (...messages) => console.log(`[${level}]`, ...messages);
+    }
+    return () => {
+        // Nothing to do.
+    };
+}
+function makeToServer(send, consoleLog) {
+    const middleware = send ? createSendMiddleware(send) : (_, cb) => cb;
+    return {
+        error: middleware("error", consoleLog.error),
+        warn: middleware("warn", consoleLog.warn),
+        info: middleware("info", consoleLog.info),
+        trace: middleware("trace", consoleLog.trace),
+        debug: middleware("debug", consoleLog.debug),
+    };
+}
+function createSendMiddleware(options) {
+    const logErrorFromBackend = toLevelNum(options.minLevel ?? "none") >= toLevelNum("error");
+    const postLog = options.sendToServer
+        ? new PostLogToBackend({
+            sendToServer: options.sendToServer,
+            logErrorFromBackend,
+        })
+        : undefined;
+    return (level, cb) => (...message) => {
+        cb(...message);
+        if (postLog) {
+            postLog.addLogLineToPost({
+                message,
+                level,
+            });
+        }
+    };
+}
+function toLevelNum(level) {
+    switch (level) {
+        case "none":
+            return 0;
+        case "error":
+            return 1;
+        case "warn":
+            return 2;
+        case "info":
+            return 3;
+        case "trace":
+            return 4;
+        case "debug":
+            return 5;
+        default:
+            throw new Error(`Invalid level: ${level}`);
+    }
+}
+class PostLogToBackend {
+    options;
+    lines = [];
+    timeoutId;
+    constructor(options) {
+        this.options = options;
+    }
+    addLogLineToPost(line) {
+        this.lines.push(line);
+        this.delayedSend();
+    }
+    delayedSend() {
+        if (this.timeoutId !== undefined) {
+            if (this.lines.length >= 20)
+                return;
+            clearTimeout(this.timeoutId);
+        }
+        this.timeoutId = setTimeout(() => {
+            this.timeoutId = undefined;
+            if (this.lines.length > 0) {
+                void postLogFromFrontend({
+                    ...this.options,
+                    lines: this.lines,
+                });
+                this.lines = [];
+            }
+        }, 50);
+    }
+}
+async function postLogFromFrontend({ lines, sendToServer, logErrorFromBackend, }) {
+    try {
+        for (const line of lines)
+            line.message = line.message.map(anyMessageToStringifiable);
+        await sendToServer(lines);
+    }
+    catch (err) {
+        if (logErrorFromBackend && window.console?.error) {
+            console.error("Cannot send log to backend:", err);
+        }
+    }
+}
+function anyMessageToStringifiable(message) {
+    if (message === null)
+        return null;
+    if (Number.isNaN(message))
+        return "[NaN]";
+    if (Array.isArray(message))
+        return message.map((item) => anyMessageToStringifiable(item));
+    if (message instanceof Error)
+        return message.message ?? message.name ?? "[Error]";
+    switch (typeof message) {
+        case "string":
+        case "number":
+        case "boolean":
+            return message;
+        case "undefined":
+            return null;
+        case "bigint":
+            return `${message.toString()}n`;
+        case "function":
+            return "[Function]";
+        case "symbol":
+            return "[Symbol]";
+        case "object": {
+            const obj = {};
+            for (const key of Object.keys(message))
+                obj[key] = anyMessageToStringifiable(message[key]);
+            return obj;
+        }
+        default:
+            return "[Unexpected value]";
+    }
+}
+function makeWrapAsync(logger) {
+    return (fn) => (...args) => {
+        fn(...args).catch(logger.error);
+    };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@paroicms/ui-logger",
+  "version": "1.12.0",
+  "description": "Logger for the Admin UI front of a Paroi CMS.",
+  "keywords": [
+    "paroicms",
+    "logger",
+    "front-log"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/paroi/opensource/paroicms.git",
+    "directory": "packages/ui-logger"
+  },
+  "author": "Paroi Team",
+  "license": "MIT",
+  "type": "module",
+  "module": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clear": "rimraf dist/*",
+    "dev": "tsc --watch --preserveWatchOutput"
+  },
+  "devDependencies": {
+    "rimraf": "~6.0.1",
+    "typescript": "~5.8.3",
+    "react": "~19.1.0"
+  },
+  "files": [
+    "dist"
+  ]
+}