@dynamic-labs/logger 0.0.0-exp20240808.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# logger
+
+Generic logger that wraps console.log with support of log levels and formatting messages.
+
+Features:
+
+1. Create a new named logger `new Logger(name, LogLevel.INFO)`
+2. Formats log messages: `[name] [level]: message`
+3. Supports additional arguments just like console log
+4. Change the loglevel with `logger.setLogLevel(LogLevel)`
+
+## Building
+
+Run `nx build logger` to build the library.
+
+## Running unit tests
+
+Run `nx test logger` to execute the unit tests via [Jest](https://jestjs.io).

package/_virtual/_tslib.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;

package/_virtual/_tslib.js

@@ -0,0 +1,32 @@
+'use client'
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __awaiter };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dynamic-labs/logger",
+  "version": "0.0.0-exp20240808.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
+    "directory": "packages/logger"
+  },
+  "description": "A simple client side logging library used in Dynamic SDK",
+  "bugs": {
+    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
+  },
+  "homepage": "https://github.com/dynamic-labs/DynamicAuth/main/packages/logger#readme",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "eventemitter3": "5.0.1"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,214 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var EventEmitter = require('eventemitter3');
+var types = require('./types.cjs');
+var deepMerge = require('./utils/deepMerge.cjs');
+var processArgs = require('./utils/processArgs.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+/* eslint-disable @typescript-eslint/no-explicit-any, no-console */
+const IGNORE_MESSAGES = ['Failed to send logs to server'];
+const messageQueue = [];
+class Logger {
+    constructor(name, level) {
+        this.name = name;
+        this.meta = undefined;
+        if (level === undefined && process.env['NODE_ENV'] !== 'production') {
+            this.level = types.LogLevel.DEBUG;
+        }
+        else if (level === undefined) {
+            this.level = types.LogLevel.WARN;
+        }
+        else {
+            this.level = level;
+        }
+    }
+    static setEmitErrors(emit) {
+        if (emit !== undefined) {
+            Logger.globalKeys.emitErrors = emit;
+        }
+    }
+    static setEnvironmentId(environmentId) {
+        if (environmentId !== undefined) {
+            Logger.globalKeys.environmentId = environmentId;
+        }
+    }
+    setMetaData(key, value) {
+        if (!this.meta) {
+            this.meta = {};
+        }
+        const data = {};
+        key.split('.').reduce((acc, k, i, arr) => {
+            if (i === arr.length - 1) {
+                acc[k] = value;
+            }
+            else {
+                if (!acc[k]) {
+                    acc[k] = {};
+                }
+                return acc[k];
+            }
+        }, data);
+        this.meta = deepMerge.deepMerge(this.meta, data);
+    }
+    getNameArray(name) {
+        return Array.isArray(name) ? name : [name];
+    }
+    createLogger(name, level) {
+        return new Logger([...this.getNameArray(this.name), ...this.getNameArray(name)], level !== null && level !== void 0 ? level : this.level);
+    }
+    get logLevel() {
+        return types.LogLevel[this.level];
+    }
+    setLogLevel(level) {
+        if (level in types.LogLevel && typeof level === 'string') {
+            this.level = types.LogLevel[level];
+        }
+        else if (level in types.LogLevel && typeof level === 'number') {
+            this.level = level;
+        }
+        else {
+            throw new Error(`Invalid log level: ${level}`);
+        }
+    }
+    formatMessage(level, message) {
+        var _a;
+        if (message instanceof Error) {
+            message = message.stack;
+        }
+        else if (
+        // Handle Error-Like Objects
+        message instanceof Object &&
+            Object.prototype.hasOwnProperty.call(message, 'stack')) {
+            message = message.stack;
+        }
+        else if (message instanceof Object) {
+            message = JSON.stringify(message);
+        }
+        const names = (Array.isArray(this.name) ? this.name : [this.name]).map((name) => `[${name}]`);
+        return `${names.join('')} [${(_a = types.LogLevel[level]) !== null && _a !== void 0 ? _a : 'TROUBLESHOOTING'}]: ${message}`;
+    }
+    captureAndSend(level, message, ...args) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (Logger.globalKeys.emitErrors &&
+                !IGNORE_MESSAGES.includes(message === null || message === void 0 ? void 0 : message.toString()) &&
+                typeof window !== 'undefined') {
+                this.emitHttpLogs(level, message, { args });
+            }
+        });
+    }
+    emitHttpLogs(level, message, { args = [], transformMeta = (meta) => meta }) {
+        messageQueue.push({ args, level, message });
+        if (messageQueue.length === 1) {
+            /**
+             * Batching the logs to send them in a single request
+             * https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide#batching_operations
+             *
+             * Essentially, multiple calls to log in the same event loop will be batched into a single request
+             */
+            queueMicrotask(() => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const messages = [];
+                messageQueue.forEach((msg) => {
+                    var _a, _b, _c, _d, _e;
+                    const body = {};
+                    const { objectArgs, remainingArgs } = processArgs.processArgs(msg);
+                    Object.assign(body, ...objectArgs);
+                    Object.assign(body, {
+                        level: types.LogLevel[msg.level],
+                        message: [msg.message, ...remainingArgs].join(' '),
+                        meta: transformMeta(this.meta),
+                        url: {
+                            hostname: (_a = window.location) === null || _a === void 0 ? void 0 : _a.hostname,
+                            origin: (_b = window.location) === null || _b === void 0 ? void 0 : _b.origin,
+                            pathname: (_c = window.location) === null || _c === void 0 ? void 0 : _c.pathname,
+                            port: (_d = window.location) === null || _d === void 0 ? void 0 : _d.port,
+                            protocol: (_e = window.location) === null || _e === void 0 ? void 0 : _e.protocol,
+                        },
+                    });
+                    messages.push(body);
+                });
+                try {
+                    if (!((_a = Logger.globalKeys) === null || _a === void 0 ? void 0 : _a.environmentId)) {
+                        throw new Error('Environment ID not set');
+                    }
+                    yield fetch(`https://logs.dynamicauth.com/api/v1/${(_b = Logger.globalKeys) === null || _b === void 0 ? void 0 : _b.environmentId}`, {
+                        body: JSON.stringify(messages),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        method: 'POST',
+                        mode: 'cors',
+                        referrerPolicy: 'origin-when-cross-origin',
+                    });
+                }
+                catch (error) {
+                    this.debug('Failed to send logs to server', error);
+                }
+                messageQueue.length = 0;
+            }));
+        }
+    }
+    /**
+     * Emits an INFO type message to the backend for analysis and debugging
+     */
+    instrument(message, options) {
+        return this.emitHttpLogs(types.LogLevel.INFO, message, {
+            args: [options],
+            // Don't send any meta to avoid storing PII
+            transformMeta: () => undefined,
+        });
+    }
+    log(level, message, ...args) {
+        const enableTroubleshootMode = typeof window !== 'undefined' &&
+            (window === null || window === void 0 ? void 0 : window.dynamic_enableTroubleshootMode) === true;
+        if (!enableTroubleshootMode &&
+            (level < this.level || level === types.LogLevel.MUTE)) {
+            return;
+        }
+        const fmtMsg = this.formatMessage(level, message);
+        switch (level) {
+            case types.LogLevel.WARN:
+                console.warn(fmtMsg, ...args);
+                break;
+            case types.LogLevel.ERROR:
+                console.error(fmtMsg, ...args);
+                break;
+            default:
+                console.log(fmtMsg, ...args);
+        }
+        if (level === types.LogLevel.ERROR) {
+            this.captureAndSend(level, message, ...args);
+        }
+    }
+    debug(message, ...args) {
+        this.log(types.LogLevel.DEBUG, message, ...args);
+    }
+    info(message, ...args) {
+        this.log(types.LogLevel.INFO, message, ...args);
+    }
+    warn(message, ...args) {
+        this.log(types.LogLevel.WARN, message, ...args);
+    }
+    error(message, ...args) {
+        Logger.events.emit('error', message);
+        this.log(types.LogLevel.ERROR, message, ...args);
+    }
+}
+Logger.globalKeys = {
+    emitErrors: true,
+};
+Logger.events = new EventEmitter__default["default"]();
+
+Object.defineProperty(exports, 'LogLevel', {
+  enumerable: true,
+  get: function () { return types.LogLevel; }
+});
+exports.Logger = Logger;

package/src/index.d.ts

@@ -0,0 +1,48 @@
+import EventEmitter from 'eventemitter3';
+import { LogLevel, Message } from './types';
+export { LogLevel, type Message } from './types';
+type EmitHttpOptions = {
+    args?: any[];
+    transformMeta?: (meta: Record<string, any> | undefined) => Record<string, any> | undefined;
+};
+export type InstrumentOptions = {
+    extraArgs?: NonNullable<EmitHttpOptions['args']>;
+    /** Identifies which resource is being instrumented */
+    key: string;
+    /** Instrumentation does not use meta so this needs to be explicit */
+    environmentId: string;
+    /** Measurement in MS the operation took to complete */
+    time: number;
+    appName?: string;
+    userId?: string;
+    primaryWalletId?: string;
+};
+export declare class Logger {
+    private name;
+    private level;
+    private static globalKeys;
+    private meta;
+    constructor(name: string | string[], level?: LogLevel);
+    static setEmitErrors(emit?: boolean): void;
+    static setEnvironmentId(environmentId?: string): void;
+    static events: EventEmitter<{
+        error: Message;
+    }, any>;
+    setMetaData(key: string, value: any): void;
+    private getNameArray;
+    createLogger(name: string | string[], level?: LogLevel): Logger;
+    get logLevel(): string;
+    setLogLevel(level: LogLevel | keyof typeof LogLevel): void;
+    private formatMessage;
+    private captureAndSend;
+    emitHttpLogs(level: LogLevel, message: Message, { args, transformMeta }: EmitHttpOptions): void;
+    /**
+     * Emits an INFO type message to the backend for analysis and debugging
+     */
+    instrument(message: Message, options: InstrumentOptions & Record<string, unknown>): void;
+    log(level: LogLevel, message: Message, ...args: any[]): void;
+    debug(message: Message, ...args: any[]): void;
+    info(message: Message, ...args: any[]): void;
+    warn(message: Message, ...args: any[]): void;
+    error(message: Message, ...args: any[]): void;
+}

package/src/index.js

@@ -0,0 +1,203 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import EventEmitter from 'eventemitter3';
+import { LogLevel } from './types.js';
+export { LogLevel } from './types.js';
+import { deepMerge } from './utils/deepMerge.js';
+import { processArgs } from './utils/processArgs.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any, no-console */
+const IGNORE_MESSAGES = ['Failed to send logs to server'];
+const messageQueue = [];
+class Logger {
+    constructor(name, level) {
+        this.name = name;
+        this.meta = undefined;
+        if (level === undefined && process.env['NODE_ENV'] !== 'production') {
+            this.level = LogLevel.DEBUG;
+        }
+        else if (level === undefined) {
+            this.level = LogLevel.WARN;
+        }
+        else {
+            this.level = level;
+        }
+    }
+    static setEmitErrors(emit) {
+        if (emit !== undefined) {
+            Logger.globalKeys.emitErrors = emit;
+        }
+    }
+    static setEnvironmentId(environmentId) {
+        if (environmentId !== undefined) {
+            Logger.globalKeys.environmentId = environmentId;
+        }
+    }
+    setMetaData(key, value) {
+        if (!this.meta) {
+            this.meta = {};
+        }
+        const data = {};
+        key.split('.').reduce((acc, k, i, arr) => {
+            if (i === arr.length - 1) {
+                acc[k] = value;
+            }
+            else {
+                if (!acc[k]) {
+                    acc[k] = {};
+                }
+                return acc[k];
+            }
+        }, data);
+        this.meta = deepMerge(this.meta, data);
+    }
+    getNameArray(name) {
+        return Array.isArray(name) ? name : [name];
+    }
+    createLogger(name, level) {
+        return new Logger([...this.getNameArray(this.name), ...this.getNameArray(name)], level !== null && level !== void 0 ? level : this.level);
+    }
+    get logLevel() {
+        return LogLevel[this.level];
+    }
+    setLogLevel(level) {
+        if (level in LogLevel && typeof level === 'string') {
+            this.level = LogLevel[level];
+        }
+        else if (level in LogLevel && typeof level === 'number') {
+            this.level = level;
+        }
+        else {
+            throw new Error(`Invalid log level: ${level}`);
+        }
+    }
+    formatMessage(level, message) {
+        var _a;
+        if (message instanceof Error) {
+            message = message.stack;
+        }
+        else if (
+        // Handle Error-Like Objects
+        message instanceof Object &&
+            Object.prototype.hasOwnProperty.call(message, 'stack')) {
+            message = message.stack;
+        }
+        else if (message instanceof Object) {
+            message = JSON.stringify(message);
+        }
+        const names = (Array.isArray(this.name) ? this.name : [this.name]).map((name) => `[${name}]`);
+        return `${names.join('')} [${(_a = LogLevel[level]) !== null && _a !== void 0 ? _a : 'TROUBLESHOOTING'}]: ${message}`;
+    }
+    captureAndSend(level, message, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Logger.globalKeys.emitErrors &&
+                !IGNORE_MESSAGES.includes(message === null || message === void 0 ? void 0 : message.toString()) &&
+                typeof window !== 'undefined') {
+                this.emitHttpLogs(level, message, { args });
+            }
+        });
+    }
+    emitHttpLogs(level, message, { args = [], transformMeta = (meta) => meta }) {
+        messageQueue.push({ args, level, message });
+        if (messageQueue.length === 1) {
+            /**
+             * Batching the logs to send them in a single request
+             * https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide#batching_operations
+             *
+             * Essentially, multiple calls to log in the same event loop will be batched into a single request
+             */
+            queueMicrotask(() => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const messages = [];
+                messageQueue.forEach((msg) => {
+                    var _a, _b, _c, _d, _e;
+                    const body = {};
+                    const { objectArgs, remainingArgs } = processArgs(msg);
+                    Object.assign(body, ...objectArgs);
+                    Object.assign(body, {
+                        level: LogLevel[msg.level],
+                        message: [msg.message, ...remainingArgs].join(' '),
+                        meta: transformMeta(this.meta),
+                        url: {
+                            hostname: (_a = window.location) === null || _a === void 0 ? void 0 : _a.hostname,
+                            origin: (_b = window.location) === null || _b === void 0 ? void 0 : _b.origin,
+                            pathname: (_c = window.location) === null || _c === void 0 ? void 0 : _c.pathname,
+                            port: (_d = window.location) === null || _d === void 0 ? void 0 : _d.port,
+                            protocol: (_e = window.location) === null || _e === void 0 ? void 0 : _e.protocol,
+                        },
+                    });
+                    messages.push(body);
+                });
+                try {
+                    if (!((_a = Logger.globalKeys) === null || _a === void 0 ? void 0 : _a.environmentId)) {
+                        throw new Error('Environment ID not set');
+                    }
+                    yield fetch(`https://logs.dynamicauth.com/api/v1/${(_b = Logger.globalKeys) === null || _b === void 0 ? void 0 : _b.environmentId}`, {
+                        body: JSON.stringify(messages),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        method: 'POST',
+                        mode: 'cors',
+                        referrerPolicy: 'origin-when-cross-origin',
+                    });
+                }
+                catch (error) {
+                    this.debug('Failed to send logs to server', error);
+                }
+                messageQueue.length = 0;
+            }));
+        }
+    }
+    /**
+     * Emits an INFO type message to the backend for analysis and debugging
+     */
+    instrument(message, options) {
+        return this.emitHttpLogs(LogLevel.INFO, message, {
+            args: [options],
+            // Don't send any meta to avoid storing PII
+            transformMeta: () => undefined,
+        });
+    }
+    log(level, message, ...args) {
+        const enableTroubleshootMode = typeof window !== 'undefined' &&
+            (window === null || window === void 0 ? void 0 : window.dynamic_enableTroubleshootMode) === true;
+        if (!enableTroubleshootMode &&
+            (level < this.level || level === LogLevel.MUTE)) {
+            return;
+        }
+        const fmtMsg = this.formatMessage(level, message);
+        switch (level) {
+            case LogLevel.WARN:
+                console.warn(fmtMsg, ...args);
+                break;
+            case LogLevel.ERROR:
+                console.error(fmtMsg, ...args);
+                break;
+            default:
+                console.log(fmtMsg, ...args);
+        }
+        if (level === LogLevel.ERROR) {
+            this.captureAndSend(level, message, ...args);
+        }
+    }
+    debug(message, ...args) {
+        this.log(LogLevel.DEBUG, message, ...args);
+    }
+    info(message, ...args) {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+    warn(message, ...args) {
+        this.log(LogLevel.WARN, message, ...args);
+    }
+    error(message, ...args) {
+        Logger.events.emit('error', message);
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+}
+Logger.globalKeys = {
+    emitErrors: true,
+};
+Logger.events = new EventEmitter();
+
+export { Logger };

package/src/types.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+exports.LogLevel = void 0;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["MUTE"] = 99] = "MUTE";
+})(exports.LogLevel || (exports.LogLevel = {}));

package/src/types.d.ts

@@ -0,0 +1,13 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    MUTE = 99
+}
+export type Message = string | Error | unknown;
+export type MessageQueueMessage = {
+    level: LogLevel;
+    message: Message;
+    args: any[];
+};

package/src/types.js

@@ -0,0 +1,11 @@
+'use client'
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["MUTE"] = 99] = "MUTE";
+})(LogLevel || (LogLevel = {}));
+
+export { LogLevel };