@sytone/markdown-snippet-injector/dist/log.js

The MarkDown snippet injector generates MD code snippets by extracting them from the source code of your projects.

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.log = exports.Logger = exports.ImmutableLogger = exports.presets = exports.callableLevelNames = exports.levelNames = exports.emoji = exports.printCodePresets = exports.printCodes = exports.Level = void 0;
/* eslint-disable no-mixed-spaces-and-tabs */
const process = __importStar(require("node:process"));
/** Log levels in ascending order of verbosity. */
var Level;
(function (Level) {
    Level[Level["none"] = 0] = "none";
    Level[Level["error"] = 1] = "error";
    Level[Level["warning"] = 2] = "warning";
    Level[Level["info"] = 3] = "info";
    Level[Level["verbose"] = 4] = "verbose";
    Level[Level["debug"] = 5] = "debug";
})(Level || (exports.Level = Level = {}));
/** Escape codes for pretty printing. */
exports.printCodes = {
    reset: '\u001B[0m',
    /** Should act as bold in modern terminals */
    bright: '\u001B[1m',
    dim: '\u001B[2m',
    underscore: '\u001B[4m',
    blink: '\u001B[5m',
    reverse: '\u001B[7m',
    hidden: '\u001B[8m',
    black: '\u001B[30m',
    red: '\u001B[31m',
    green: '\u001B[32m',
    yellow: '\u001B[33m',
    blue: '\u001B[34m',
    magenta: '\u001B[35m',
    cyan: '\u001B[36m',
    white: '\u001B[37m',
};
/** The codes we use per level in the presets */
exports.printCodePresets = {
    [Level.error]: exports.printCodes.red + exports.printCodes.bright,
    [Level.warning]: exports.printCodes.yellow,
    [Level.info]: '',
    [Level.verbose]: exports.printCodes.blue,
    [Level.debug]: exports.printCodes.green,
};
/** Emojis for pretty printing. */
exports.emoji = {
    [Level.error]: '🚫',
    [Level.warning]: '⚠️',
    [Level.info]: 'ℹ️',
    [Level.verbose]: '🗣️',
    [Level.debug]: '🐛',
};
/** Collection of log level names, useful for passing around and iteration. */
exports.levelNames = ['none', 'error', 'warning', 'info', 'verbose', 'debug'];
/**
 * Collection of log level names sans `none`, useful for passing around and
 * iteration.
 */
exports.callableLevelNames = ['error', 'warning', 'info', 'verbose', 'debug'];
/** Determine wether a CallableLevelRecordable is a CallableLevelRecord. */
function isCallableLevelRecord(value) {
    // Check for value being a proper object
    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
        return false;
    }
    // Value is definitely a regular object
    const keys = Object.keys(value);
    const expectedKeys = [
        Level.error.toString(),
        Level.warning.toString(),
        Level.info.toString(),
        Level.verbose.toString(),
        Level.debug.toString(),
    ];
    return (keys.length === exports.callableLevelNames.length
        && keys.sort().every((key, index) => key === expectedKeys[index]));
}
/**
 * Expand a value to each value of a CallableLevelRecord, or pass through a
 * CallableLevelRecord.
 */
function expandToCallableLevelRecord(value) {
    return isCallableLevelRecord(value)
        ? value
        : {
            [Level.error]: value,
            [Level.warning]: value,
            [Level.info]: value,
            [Level.verbose]: value,
            [Level.debug]: value,
        };
}
/**
 * Take a level value or its name, and return the corresponding level value.
 * Throws on invalid values.
 */
function resolveLevel(value) {
    if (typeof value === 'number') {
        // Make sure passed level is valid even at runtime (untyped usage)
        if (Level[value] === undefined) {
            throw new Error(`Invalid logging level ${value}`);
        }
        return value;
    }
    if (typeof value === 'string') {
        const targetLevel = Level[value];
        // Make sure a valid level was passed by name (untyped usage)
        if (targetLevel === undefined) {
            throw new Error(`Invalid logging level '${value}.`);
        }
        return targetLevel;
    }
    // Entirely invalid call (untyped usage)
    throw new Error(`Cannot set logging level to value of type '${typeof value}'.`);
}
/**
 * `presets` is used to generate defaults but can also be called to customise
 * them slightly
 */
exports.presets = {
    /** Pick out the logging functions from a console-like object into a CallableLevelRecord */
    getLoggingFunctions: (i = console) => ({
        [Level.error]: i.error,
        [Level.warning]: i.warn,
        [Level.info]: i.log,
        [Level.verbose]: i.info,
        [Level.debug]: i.debug,
    }),
    makeSimpleWrapper: (tags = [], dateFmt = date => date.toISOString()) => (data, level, timestamp) => 
    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
    ['[', [...tags, dateFmt(timestamp), Level[level].toUpperCase()].join(' | '), ']', ...data],
    makeFancyWrapper: (dateFmt = date => date.toLocaleTimeString()) => (data, level, timestamp) => 
    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
    [dateFmt(timestamp), '|', exports.emoji[level] + exports.printCodePresets[level], ...data, exports.printCodes.reset],
};
/**
 * ImmutableLoggers are the basis for regular Loggers. ImmutableLoggers expose
 * only logging functions.
 */
class ImmutableLogger {
    error;
    warning;
    info;
    verbose;
    debug;
    level;
    loggingFunctions;
    wrappers;
    constructor(level = Level.info, loggingFunctions = exports.presets.getLoggingFunctions(), wrappers = exports.presets.makeSimpleWrapper()) {
        this.level = resolveLevel(level);
        this.loggingFunctions = expandToCallableLevelRecord(loggingFunctions);
        this.wrappers = expandToCallableLevelRecord(wrappers);
        this.error = this.makeLoggingFunction(Level.error);
        this.warning = this.makeLoggingFunction(Level.warning);
        this.info = this.makeLoggingFunction(Level.info);
        this.verbose = this.makeLoggingFunction(Level.verbose);
        this.debug = this.makeLoggingFunction(Level.debug);
    }
    makeLoggingFunction(level) {
        return (...data) => {
            const logger = this.loggingFunctions[level];
            const wrapper = this.wrappers[level];
            if (this.level >= level) {
                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                logger(...wrapper(data, level, new Date()));
            }
        };
    }
}
exports.ImmutableLogger = ImmutableLogger;
/**
 * Loggers expose logging functions, in addition to functions to change
 * settings. This mutable nature makes them easier to use globally. The default
 * export of the module is a pre-instantiated Logger.
 */
class Logger extends ImmutableLogger {
    constructor(level = Level.info, loggingFunctions = exports.presets.getLoggingFunctions(), wrappers = exports.presets.makeFancyWrapper()) {
        super(level, loggingFunctions, wrappers);
    }
    setLevel(value) {
        this.level = resolveLevel(value);
    }
    setLoggingFunctions(value) {
        this.loggingFunctions = expandToCallableLevelRecord(value);
    }
    setWrappers(value) {
        this.wrappers = expandToCallableLevelRecord(value);
    }
}
exports.Logger = Logger;
exports.log = new Logger(Level.info, exports.presets.getLoggingFunctions(), process.stdout.isTTY ? exports.presets.makeFancyWrapper() : exports.presets.makeSimpleWrapper());
exports.default = exports.log;
//# sourceMappingURL=log.js.map