@kotori-bot/logger/lib/index.js

Logger For Kotori

/**
 * @Package @kotori-bot/logger
 * @Version 1.3.3
 * @Author Hotaru <me@hotaru.icu>
 * @Copyright 2024 Hotaru. All rights reserved.
 * @License GPL-3.0
 * @Link https://github.com/kotorijs/kotori
 * @Date 2025/2/15 18:31:34
 */

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var src_exports = {};
__export(src_exports, {
  Logger: () => Logger,
  default: () => src_default
});
module.exports = __toCommonJS(src_exports);
var import_common = require("./types/common");
var import_escaper = require("./utils/escaper");
var import_const = require("./const");
var import_transport = require("./transport");
__reExport(src_exports, require("./utils/escaper"), module.exports);
__reExport(src_exports, require("./utils/transport"), module.exports);
__reExport(src_exports, require("./types/common"), module.exports);
__reExport(src_exports, require("./transport"), module.exports);
__reExport(src_exports, require("./const"), module.exports);
function runTransport(transport, data, filter) {
  if (filter && !filter(data)) return;
  if (transport.options.filter && !transport.options.filter(data)) return;
  transport.handle(data);
}
class Logger {
  options;
  creator(level, args) {
    const { label, transports, filter } = this.options;
    const baseData = { level, time: (/* @__PURE__ */ new Date()).getTime(), pid: typeof process !== "undefined" ? process.pid : 0, label };
    if (!Array.isArray(transports)) {
      runTransport(transports, { ...baseData, msg: (transports.escaper ?? import_escaper.escaper)(args) }, filter);
      return;
    }
    let msg;
    for (const transport of transports) {
      if (transport.escaper) {
        runTransport(transport, { ...baseData, msg: transport.escaper(args) }, filter);
        continue;
      }
      if (msg === void 0) msg = (0, import_escaper.escaper)(args);
      runTransport(transport, { ...baseData, msg }, filter);
    }
  }
  constructor(options = import_const.DEFAULT_LOGGER_OPTIONS) {
    this.options = Object.assign(import_const.DEFAULT_LOGGER_OPTIONS, options);
  }
  extends(options = {}) {
    const proxy = new Proxy(options, {
      get: (_, prop) => {
        if (options[prop] !== void 0) return options[prop];
        return this.options[prop];
      }
    });
    return new Proxy(new Logger(), {
      get: (target, prop, receiver) => {
        if (prop === "options") return proxy;
        return Reflect.get(target, prop, receiver);
      }
    });
  }
  label(label) {
    return this.extends({ label: [...this.options.label, ...typeof label === "string" ? [label] : label] });
  }
  fatal(...args) {
    if (this.options.level > import_common.LoggerLevel.FATAL) return;
    this.creator(import_common.LoggerLevel.FATAL, args);
  }
  error(...args) {
    if (this.options.level > import_common.LoggerLevel.ERROR) return;
    this.creator(import_common.LoggerLevel.ERROR, args);
  }
  warn(...args) {
    if (this.options.level > import_common.LoggerLevel.WARN) return;
    this.creator(import_common.LoggerLevel.WARN, args);
  }
  info(...args) {
    if (this.options.level > import_common.LoggerLevel.INFO) return;
    this.creator(import_common.LoggerLevel.INFO, args);
  }
  record(...args) {
    if (this.options.level > import_common.LoggerLevel.RECORD) return;
    this.creator(import_common.LoggerLevel.RECORD, args);
  }
  debug(...args) {
    if (this.options.level > import_common.LoggerLevel.DEBUG) return;
    this.creator(import_common.LoggerLevel.DEBUG, args);
  }
  trace(...args) {
    if (this.options.level > import_common.LoggerLevel.TRACE) return;
    this.creator(import_common.LoggerLevel.TRACE, args);
  }
}
((Logger2) => {
  const logger = new Logger2({ level: import_common.LoggerLevel.INFO, transports: new import_transport.ConsoleTransport() });
  Logger2.fatal = logger.fatal.bind(logger);
  Logger2.error = logger.error.bind(logger);
  Logger2.warn = logger.warn.bind(logger);
  Logger2.info = logger.info.bind(logger);
})(Logger || (Logger = {}));
var src_default = Logger;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Logger,
  ...require("./utils/escaper"),
  ...require("./utils/transport"),
  ...require("./types/common"),
  ...require("./transport"),
  ...require("./const")
});