rslog 1.2.2 → 1.2.4

package/README.md

@@ -1,5 +1,13 @@
 # Rslog
 
+<p>
+  <a href="https://npmjs.com/package/rslog">
+   <img src="https://img.shields.io/npm/v/rslog?style=flat-square&colorA=564341&colorB=EDED91" alt="npm version" />
+  </a>
+  <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="license" />
+  <a href="https://npmcharts.com/compare/rslog?minimal=true"><img src="https://img.shields.io/npm/dm/rslog.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="downloads" /></a>
+</p>
+
 A tiny, intuitive, type-friendly logger for Node.js.
 
 - **Tiny**. [2kB gzipped](https://bundlephobia.com/package/rslog@1).
@@ -99,7 +107,8 @@ The log levels of each method are as follows:
 
 | Level   | Method                              |
 | ------- | ----------------------------------- |
-| error   | `error`                             |
+| silent  | No log will be output               |
+| error   | only `error` logs                   |
 | warn    | `warn`                              |
 | info    | `info`, `start`, `ready`, `success` |
 | log     | `log`                               |

package/dist/color.d.ts

@@ -0,0 +1,8 @@
+export type ColorFn = (input: string | number | null | undefined) => string;
+export declare const bold: ColorFn;
+export declare const red: ColorFn;
+export declare const green: ColorFn;
+export declare const yellow: ColorFn;
+export declare const magenta: ColorFn;
+export declare const cyan: ColorFn;
+export declare const gray: ColorFn;

package/dist/constants.d.ts

@@ -0,0 +1,48 @@
+export declare let LOG_LEVEL: {
+    readonly silent: -1;
+    readonly error: 0;
+    readonly warn: 1;
+    readonly info: 2;
+    readonly log: 3;
+    readonly verbose: 4;
+};
+export declare let LOG_TYPES: {
+    error: {
+        label: string;
+        level: "error";
+        color: import("./color").ColorFn;
+    };
+    warn: {
+        label: string;
+        level: "warn";
+        color: import("./color").ColorFn;
+    };
+    info: {
+        label: string;
+        level: "info";
+        color: import("./color").ColorFn;
+    };
+    start: {
+        label: string;
+        level: "info";
+        color: import("./color").ColorFn;
+    };
+    ready: {
+        label: string;
+        level: "info";
+        color: import("./color").ColorFn;
+    };
+    success: {
+        label: string;
+        level: "info";
+        color: import("./color").ColorFn;
+    };
+    log: {
+        level: "log";
+    };
+    debug: {
+        label: string;
+        level: "verbose";
+        color: import("./color").ColorFn;
+    };
+};

package/dist/createLogger.d.ts

@@ -0,0 +1,2 @@
+import type { Options, Logger } from './types';
+export declare let createLogger: (options?: Options) => Logger;

package/dist/gradient.d.ts

@@ -0,0 +1 @@
+export declare let gradient: (message: string) => string;

package/dist/index.d.ts

@@ -1,66 +1,3 @@
-type ColorFn = (input: string | number | null | undefined) => string;
-
-declare let LOG_TYPES: {
-    error: {
-        label: string;
-        level: "error";
-        color: ColorFn;
-    };
-    warn: {
-        label: string;
-        level: "warn";
-        color: ColorFn;
-    };
-    info: {
-        label: string;
-        level: "info";
-        color: ColorFn;
-    };
-    start: {
-        label: string;
-        level: "info";
-        color: ColorFn;
-    };
-    ready: {
-        label: string;
-        level: "info";
-        color: ColorFn;
-    };
-    success: {
-        label: string;
-        level: "info";
-        color: ColorFn;
-    };
-    log: {
-        level: "log";
-    };
-    debug: {
-        label: string;
-        level: "verbose";
-        color: ColorFn;
-    };
-};
-
-type LogLevel = 'error' | 'warn' | 'info' | 'log' | 'verbose';
-type LogMessage = unknown;
-interface LogType {
-    label?: string;
-    level: LogLevel;
-    color?: ColorFn;
-}
-type LogFunction = (message?: LogMessage, ...args: any[]) => void;
-interface Options {
-    level?: LogLevel;
-}
-type LogMethods = keyof typeof LOG_TYPES;
-type Logger = Record<LogMethods, LogFunction> & {
-    greet: (message: string) => void;
-    level: LogLevel;
-    override: (customLogger: Partial<Record<LogMethods, LogFunction>>) => void;
-};
-
-declare let createLogger: (options?: Options) => Logger;
-
-declare let logger: Logger;
-
-export { type LogFunction, type LogLevel, type LogMessage, type LogType, type Logger, type Options, createLogger, logger };
+export { createLogger } from './createLogger';
+export declare let logger: import("./types").Logger;
+export type { Options, Logger, LogType, LogLevel, LogMessage, LogFunction, } from './types';

package/dist/index.js

@@ -0,0 +1,274 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createLogger: ()=>createLogger,
+    logger: ()=>src_logger
+});
+const external_node_process_namespaceObject = require("node:process");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_tty_namespaceObject = require("node:tty");
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : external_node_process_namespaceObject.argv) {
+    const prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--';
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+}
+const { env } = external_node_process_namespaceObject;
+let flagForceColor;
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) flagForceColor = 0;
+else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) flagForceColor = 1;
+function envForceColor() {
+    if ('FORCE_COLOR' in env) {
+        if ('true' === env.FORCE_COLOR) return 1;
+        if ('false' === env.FORCE_COLOR) return 0;
+        return 0 === env.FORCE_COLOR.length ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    }
+}
+function translateLevel(level) {
+    if (0 === level) return false;
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+    };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (0 === forceColor) return 0;
+    if (sniffFlags) {
+        if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
+        if (hasFlag('color=256')) return 2;
+    }
+    if ('TF_BUILD' in env && 'AGENT_NAME' in env) return 1;
+    if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+    const min = forceColor || 0;
+    if ('dumb' === env.TERM) return min;
+    if ('win32' === external_node_process_namespaceObject.platform) {
+        const osRelease = external_node_os_namespaceObject.release().split('.');
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        return 1;
+    }
+    if ('CI' in env) {
+        if ('GITHUB_ACTIONS' in env || 'GITEA_ACTIONS' in env) return 3;
+        if ([
+            'TRAVIS',
+            'CIRCLECI',
+            'APPVEYOR',
+            'GITLAB_CI',
+            'BUILDKITE',
+            'DRONE'
+        ].some((sign)=>sign in env) || 'codeship' === env.CI_NAME) return 1;
+        return min;
+    }
+    if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    if ('truecolor' === env.COLORTERM) return 3;
+    if ('xterm-kitty' === env.TERM) return 3;
+    if ('TERM_PROGRAM' in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+        switch(env.TERM_PROGRAM){
+            case 'iTerm.app':
+                return version >= 3 ? 3 : 2;
+            case 'Apple_Terminal':
+                return 2;
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) return 2;
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+    if ('COLORTERM' in env) return 1;
+    return min;
+}
+function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+    });
+    return translateLevel(level);
+}
+const supportsColor = {
+    stdout: createSupportsColor({
+        isTTY: external_node_tty_namespaceObject.isatty(1)
+    }),
+    stderr: createSupportsColor({
+        isTTY: external_node_tty_namespaceObject.isatty(2)
+    })
+};
+const supports_color = supportsColor;
+const colorLevel = supports_color.stdout ? supports_color.stdout.level : 0;
+let errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
+let anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
+let isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+let formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
+        let string = '' + input;
+        let index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    } : String;
+let replaceClose = (string, close, replace, index)=>{
+    let start = string.substring(0, index) + replace;
+    let end = string.substring(index + close.length);
+    let nextIndex = end.indexOf(close);
+    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m');
+const red = formatter('\x1b[31m', '\x1b[39m');
+const green = formatter('\x1b[32m', '\x1b[39m');
+const yellow = formatter('\x1b[33m', '\x1b[39m');
+const magenta = formatter('\x1b[35m', '\x1b[39m');
+const cyan = formatter('\x1b[36m', '\x1b[39m');
+const gray = formatter('\x1b[90m', '\x1b[39m');
+let startColor = [
+    189,
+    255,
+    243
+];
+let endColor = [
+    74,
+    194,
+    154
+];
+let isWord = (char)=>!/[\s\n]/.test(char);
+let gradient = (message)=>{
+    if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
+    let chars = [
+        ...message
+    ];
+    let steps = chars.filter(isWord).length;
+    let r = startColor[0];
+    let g = startColor[1];
+    let b = startColor[2];
+    let rStep = (endColor[0] - r) / steps;
+    let gStep = (endColor[1] - g) / steps;
+    let bStep = (endColor[2] - b) / steps;
+    let output = '';
+    for (let char of chars){
+        if (isWord(char)) {
+            r += rStep;
+            g += gStep;
+            b += bStep;
+        }
+        output += `\x1b[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1b[39m`;
+    }
+    return bold(output);
+};
+let LOG_LEVEL = {
+    silent: -1,
+    error: 0,
+    warn: 1,
+    info: 2,
+    log: 3,
+    verbose: 4
+};
+let LOG_TYPES = {
+    error: {
+        label: 'error',
+        level: 'error',
+        color: red
+    },
+    warn: {
+        label: 'warn',
+        level: 'warn',
+        color: yellow
+    },
+    info: {
+        label: 'info',
+        level: 'info',
+        color: cyan
+    },
+    start: {
+        label: 'start',
+        level: 'info',
+        color: cyan
+    },
+    ready: {
+        label: 'ready',
+        level: 'info',
+        color: green
+    },
+    success: {
+        label: 'success',
+        level: 'info',
+        color: green
+    },
+    log: {
+        level: 'log'
+    },
+    debug: {
+        label: 'debug',
+        level: 'verbose',
+        color: magenta
+    }
+};
+let createLogger = (options = {})=>{
+    let maxLevel = options.level || 'log';
+    let log = (type, message, ...args)=>{
+        if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
+        if (null == message) return console.log();
+        let logType = LOG_TYPES[type];
+        let label = '';
+        let text = '';
+        if ('label' in logType) {
+            label = (logType.label || '').padEnd(7);
+            label = bold(logType.color ? logType.color(label) : label);
+        }
+        if (message instanceof Error) {
+            if (message.stack) {
+                let [name, ...rest] = message.stack.split('\n');
+                if (name.startsWith('Error: ')) name = name.slice(7);
+                text = `${name}\n${gray(rest.join('\n'))}`;
+            } else text = message.message;
+        } else if ('error' === logType.level && 'string' == typeof message) {
+            let lines = message.split('\n');
+            text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join('\n');
+        } else text = `${message}`;
+        console.log(label.length ? `${label} ${text}` : text, ...args);
+    };
+    let logger = {
+        greet: (message)=>log('log', gradient(message))
+    };
+    Object.keys(LOG_TYPES).forEach((key)=>{
+        logger[key] = (...args)=>log(key, ...args);
+    });
+    Object.defineProperty(logger, 'level', {
+        get: ()=>maxLevel,
+        set (val) {
+            maxLevel = val;
+        }
+    });
+    logger.override = (customLogger)=>{
+        Object.assign(logger, customLogger);
+    };
+    return logger;
+};
+let src_logger = createLogger();
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});