@reliverse/relinka 1.4.5 → 1.4.7

package/bin/deprecated/components/relinka-deprecated/relinka.js

@@ -1,381 +0,0 @@
-import { defu } from "defu";
-import { LogTypesDeprecated } from "../modes/shared.js";
-import { isLogObj } from "../../utils/log.js";
-export class RelinkaInterface {
-  options;
-  _lastLog;
-  // Instance properties for paused state and queue
-  _paused;
-  _queue;
-  _mockFn;
-  /**
-   * Creates an instance of Relinka with specified options or defaults.
-   *
-   * @param {Partial<RelinkaOptionsDeprecated>} [options={}] - Configuration options for the Relinka instance.
-   */
-  constructor(options = {}) {
-    const types = options.types || LogTypesDeprecated;
-    this.options = defu(
-      {
-        ...options,
-        defaults: { ...options.defaults },
-        level: _normalizeLogLevelDeprecated(options.level, types),
-        reporters: [...options.reporters || []]
-      },
-      {
-        types: LogTypesDeprecated,
-        throttle: 1e3,
-        throttleMin: 5,
-        formatOptions: {
-          date: true,
-          colors: false,
-          compact: true
-        }
-      }
-    );
-    for (const type in types) {
-      const defaults = {
-        type,
-        ...this.options.defaults,
-        ...types[type]
-      };
-      this[type] = this._wrapLogFn(defaults);
-      this[type].raw = this._wrapLogFn(defaults, true);
-    }
-    if (this.options.mockFn) {
-      this.mockTypes();
-    }
-    this._lastLog = {};
-    this._paused = false;
-    this._queue = [];
-  }
-  /**
-   * Gets the current log level of the Relinka instance.
-   *
-   * @returns {number} The current log level.
-   */
-  get level() {
-    return this.options.level;
-  }
-  /**
-   * Sets the minimum log level that will be output by the instance.
-   *
-   * @param {number} level - The new log level to set.
-   */
-  set level(level) {
-    this.options.level = _normalizeLogLevelDeprecated(
-      level,
-      this.options.types,
-      this.options.level
-    );
-  }
-  /**
-   * Creates a new instance of Relinka, inheriting options from the current instance, with possible overrides.
-   *
-   * @param {Partial<RelinkaOptionsDeprecated>} options - Optional overrides for the new instance. See {@link RelinkaOptionsDeprecated}.
-   * @returns {RelinkaInstanceDeprecated} A new Relinka instance. See {@link RelinkaInstanceDeprecated}.
-   */
-  create(options) {
-    const instance = new RelinkaInterface({
-      ...this.options,
-      ...options
-    });
-    if (this._mockFn) {
-      instance.mockTypes(this._mockFn);
-    }
-    return instance;
-  }
-  /**
-   * Creates a new Relinka instance with the specified default log object properties.
-   *
-   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
-   * @returns {RelinkaInstanceDeprecated} A new Relinka instance. See {@link RelinkaInstanceDeprecated}.
-   */
-  withDefaults(defaults) {
-    return this.create({
-      ...this.options,
-      defaults: {
-        ...this.options.defaults,
-        ...defaults
-      }
-    });
-  }
-  /**
-   * Creates a new Relinka instance with a specified tag, which will be included in every log.
-   *
-   * @param {string} tag - The tag to include in each log of the new instance.
-   * @returns {RelinkaInstanceDeprecated} A new Relinka instance. See {@link RelinkaInstanceDeprecated}.
-   */
-  withTag(tag) {
-    return this.withDefaults({
-      tag: this.options.defaults.tag ? `${this.options.defaults.tag}:${tag}` : tag
-    });
-  }
-  /**
-   * Adds a custom reporter to the Relinka instance.
-   * Reporters will be called for each log message, depending on their implementation and log level.
-   *
-   * @param {RelinkaReporterDeprecated} reporter - The reporter to add. See {@link RelinkaReporterDeprecated}.
-   * @returns {Relinka} The current Relinka instance.
-   */
-  addReporter(reporter) {
-    this.options.reporters.push(reporter);
-    return this;
-  }
-  /**
-   * Removes a custom reporter from the Relinka instance.
-   * If no reporter is specified, all reporters will be removed.
-   *
-   * @param {RelinkaReporterDeprecated} reporter - The reporter to remove. See {@link RelinkaReporterDeprecated}.
-   * @returns {Relinka} The current Relinka instance.
-   */
-  removeReporter(reporter) {
-    if (reporter) {
-      const i = this.options.reporters.indexOf(reporter);
-      if (i >= 0) {
-        return this.options.reporters.splice(i, 1);
-      }
-    } else {
-      this.options.reporters.splice(0);
-    }
-    return this;
-  }
-  /**
-   * Replaces all reporters of the Relinka instance with the specified array of reporters.
-   *
-   * @param {RelinkaReporterDeprecated[]} reporters - The new reporters to set. See {@link RelinkaReporterDeprecated}.
-   * @returns {Relinka} The current Relinka instance.
-   */
-  setReporters(reporters) {
-    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
-    return this;
-  }
-  wrapAll() {
-    this.wrapConsole();
-    this.wrapStd();
-  }
-  restoreAll() {
-    this.restoreConsole();
-    this.restoreStd();
-  }
-  /**
-   * Overrides console methods with Relinka logging methods for consistent logging.
-   */
-  wrapConsole() {
-    for (const type in this.options.types) {
-      if (!console[`__${type}`]) {
-        console[`__${type}`] = console[type];
-      }
-      console[type] = this[type].raw;
-    }
-  }
-  /**
-   * Restores the original console methods, removing Relinka overrides.
-   */
-  restoreConsole() {
-    for (const type in this.options.types) {
-      if (console[`__${type}`]) {
-        console[type] = console[`__${type}`];
-        delete console[`__${type}`];
-      }
-    }
-  }
-  /**
-   * Overrides standard output and error streams to redirect them through RelinkaInterface.
-   */
-  wrapStd() {
-    this._wrapStream(this.options.stdout, "log");
-    this._wrapStream(this.options.stderr, "log");
-  }
-  _wrapStream(stream, type) {
-    if (!stream) {
-      return;
-    }
-    if (!stream.__write) {
-      stream.__write = stream.write;
-    }
-    stream.write = (data) => {
-      this[type].raw(
-        String(data).trim()
-      );
-    };
-  }
-  /**
-   * Restores the original standard output and error streams, removing the Relinka redirection.
-   */
-  restoreStd() {
-    this._restoreStream(this.options.stdout);
-    this._restoreStream(this.options.stderr);
-  }
-  _restoreStream(stream) {
-    if (!stream) {
-      return;
-    }
-    if (stream.__write) {
-      stream.write = stream.__write;
-      stream.__write = void 0;
-    }
-  }
-  /**
-   * Clears the internal state of the Relinka instance.
-   * This will reset any throttling, last log data, clear any queued logs,
-   * and optionally clear the actual console.
-   *
-   * @param {boolean} clearConsole - Whether to clear the actual console. Defaults to false.
-   */
-  clear(clearConsole = false) {
-    this._lastLog = {};
-    this._queue = [];
-    this._paused = false;
-    if (clearConsole && typeof console.clear === "function") {
-      console.clear();
-    }
-  }
-  /**
-   * Pauses logging, queues incoming logs until resumed.
-   */
-  pauseLogs() {
-    this._paused = true;
-  }
-  /**
-   * Resumes logging, processing any queued logs.
-   */
-  resumeLogs() {
-    this._paused = false;
-    const _queue = this._queue.splice(0);
-    for (const item of _queue) {
-      item[0]._logFn(item[1], item[2]);
-    }
-  }
-  /**
-   * Replaces logging methods with mocks if a mock function is provided.
-   *
-   * @param {RelinkaOptionsDeprecated["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link RelinkaOptionsDeprecated["mockFn"]}.
-   */
-  mockTypes(mockFn) {
-    const _mockFn = mockFn || this.options.mockFn;
-    this._mockFn = _mockFn;
-    if (typeof _mockFn !== "function") {
-      return;
-    }
-    for (const type in this.options.types) {
-      this[type] = _mockFn(
-        type,
-        this.options.types[type]
-      ) || this[type];
-      this[type].raw = this[type];
-    }
-  }
-  // _wrapLogFn uses instances: _paused, _queue, etc
-  _wrapLogFn(defaults, isRaw) {
-    return (...args) => {
-      if (this._paused) {
-        this._queue.push([this, defaults, args, isRaw]);
-        return false;
-      }
-      return this._logFn(defaults, args, isRaw);
-    };
-  }
-  _logFn(defaults, args, isRaw) {
-    if ((defaults.level || 0) > this.level) {
-      return false;
-    }
-    const logObj = {
-      date: /* @__PURE__ */ new Date(),
-      args: [],
-      ...defaults,
-      level: _normalizeLogLevelDeprecated(defaults.level, this.options.types)
-    };
-    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
-      Object.assign(logObj, args[0]);
-    } else {
-      logObj.args = [...args];
-    }
-    if (logObj.message) {
-      logObj.args.unshift(logObj.message);
-      logObj.message = void 0;
-    }
-    if (logObj.additional) {
-      if (!Array.isArray(logObj.additional)) {
-        logObj.additional = logObj.additional.split("\n");
-      }
-      logObj.args.push(`
-${logObj.additional.join("\n")}`);
-      logObj.additional = void 0;
-    }
-    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
-    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
-    const resolveLog = (newLog = false) => {
-      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
-      if (this._lastLog.object && repeated > 0) {
-        const args2 = [...this._lastLog.object.args];
-        if (repeated > 1) {
-          args2.push(`(repeated ${repeated} times)`);
-        }
-        this._log({ ...this._lastLog.object, args: args2 });
-        this._lastLog.count = 1;
-      }
-      if (newLog) {
-        this._lastLog.object = logObj;
-        this._log(logObj);
-      }
-    };
-    clearTimeout(this._lastLog.timeout);
-    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
-    this._lastLog.time = logObj.date;
-    if (diffTime < this.options.throttle) {
-      try {
-        const serializedLog = JSON.stringify([
-          logObj.type,
-          logObj.tag,
-          logObj.args
-        ]);
-        const isSameLog = this._lastLog.serialized === serializedLog;
-        this._lastLog.serialized = serializedLog;
-        if (isSameLog) {
-          this._lastLog.count = (this._lastLog.count || 0) + 1;
-          if (this._lastLog.count > this.options.throttleMin) {
-            this._lastLog.timeout = setTimeout(
-              resolveLog,
-              this.options.throttle
-            );
-            return false;
-          }
-        }
-      } catch {
-        return true;
-      }
-    }
-    resolveLog(true);
-    return true;
-  }
-  _log(logObj) {
-    for (const reporter of this.options.reporters) {
-      reporter.log(logObj, {
-        options: this.options
-      });
-    }
-  }
-}
-function _normalizeLogLevelDeprecated(input, types = {}, defaultLevel = 3) {
-  if (input === void 0) {
-    return defaultLevel;
-  }
-  if (typeof input === "number") {
-    return input;
-  }
-  if (types[input] && types[input].level !== void 0) {
-    return types[input].level;
-  }
-  return defaultLevel;
-}
-RelinkaInterface.prototype.add = RelinkaInterface.prototype.addReporter;
-RelinkaInterface.prototype.remove = RelinkaInterface.prototype.removeReporter;
-RelinkaInterface.prototype.clear = RelinkaInterface.prototype.removeReporter;
-RelinkaInterface.prototype.withScope = RelinkaInterface.prototype.withTag;
-RelinkaInterface.prototype.mock = RelinkaInterface.prototype.mockTypes;
-RelinkaInterface.prototype.pause = RelinkaInterface.prototype.pauseLogs;
-RelinkaInterface.prototype.resume = RelinkaInterface.prototype.resumeLogs;
-export function createRelinkaDeprecated(options = {}) {
-  return new RelinkaInterface(options);
-}

package/bin/deprecated/components/reporters/basic.d.ts

@@ -1,11 +0,0 @@
-import type { LogObject, RelinkaReporterDeprecated, FormatOptions, RelinkaOptionsDeprecated } from "../../types.js";
-export declare class BasicReporter implements RelinkaReporterDeprecated {
-    formatStack(stack: string): string;
-    formatArgs(args: any[], opts: FormatOptions): string;
-    formatDate(date: Date, opts: FormatOptions): string;
-    filterAndJoin(arr: any[]): string;
-    formatLogObj(logObj: LogObject, opts: FormatOptions): string;
-    log(logObj: LogObject, ctx: {
-        options: RelinkaOptionsDeprecated;
-    }): any;
-}

package/bin/deprecated/components/reporters/basic.js

@@ -1,53 +0,0 @@
-import { formatWithOptions } from "node:util";
-import { parseStack } from "../../utils/error.js";
-import { writeStream } from "../../utils/stream.js";
-const bracket = (x) => x ? `[${x}]` : "";
-export class BasicReporter {
-  formatStack(stack) {
-    return `  ${parseStack(stack).join("\n  ")}`;
-  }
-  formatArgs(args, opts) {
-    const formattedArgs = args.map((arg) => {
-      if (arg && typeof arg.stack === "string") {
-        return `${arg.message}
-${this.formatStack(arg.stack)}`;
-      }
-      return arg;
-    });
-    return formatWithOptions(opts, ...formattedArgs);
-  }
-  formatDate(date, opts) {
-    return opts.date ? date.toLocaleTimeString() : "";
-  }
-  filterAndJoin(arr) {
-    return arr.filter(Boolean).join(" ");
-  }
-  formatLogObj(logObj, opts) {
-    const message = this.formatArgs(logObj.args, opts);
-    if (logObj.type === "box") {
-      return `
-${[
-        bracket(logObj.tag),
-        logObj.title && logObj.title,
-        ...message.split("\n")
-      ].filter(Boolean).map((l) => ` > ${l}`).join("\n")}
-`;
-    }
-    return this.filterAndJoin([
-      bracket(logObj.type),
-      bracket(logObj.tag),
-      message
-    ]);
-  }
-  log(logObj, ctx) {
-    const line = this.formatLogObj(logObj, {
-      columns: ctx.options.stdout.columns || 0,
-      ...ctx.options.formatOptions
-    });
-    return writeStream(
-      `${line}
-`,
-      logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout
-    );
-  }
-}

package/bin/deprecated/components/reporters/browser.d.ts

@@ -1,10 +0,0 @@
-import type { LogObject } from "../../types.js";
-export declare class BrowserReporter {
-    options: any;
-    defaultColor: string;
-    levelColorMap: Record<number, string>;
-    typeColorMap: Record<string, string>;
-    constructor(options: any);
-    _getLogFn(level: number): any;
-    log(logObj: LogObject): void;
-}

package/bin/deprecated/components/reporters/browser.js

@@ -1,56 +0,0 @@
-export class BrowserReporter {
-  options;
-  defaultColor;
-  levelColorMap;
-  typeColorMap;
-  constructor(options) {
-    this.options = { ...options };
-    this.defaultColor = "#7f8c8d";
-    this.levelColorMap = {
-      0: "#c0392b",
-      // Red
-      1: "#f39c12",
-      // Yellow
-      3: "#00BCD4"
-      // Cyan
-    };
-    this.typeColorMap = {
-      success: "#2ecc71"
-      // Green
-    };
-  }
-  _getLogFn(level) {
-    if (level < 1) {
-      return console.__error || console.error;
-    }
-    if (level === 1) {
-      return console.__warn || console.warn;
-    }
-    return console.__log || console.log;
-  }
-  log(logObj) {
-    const consoleLogFn = this._getLogFn(logObj.level);
-    const type = logObj.type === "log" ? "" : logObj.type;
-    const tag = logObj.tag || "";
-    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
-    const style = `
-      background: ${color};
-      border-radius: 0.5em;
-      color: white;
-      font-weight: bold;
-      padding: 2px 0.5em;
-    `;
-    const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
-    if (typeof logObj.args[0] === "string") {
-      consoleLogFn(
-        `${badge}%c ${logObj.args[0]}`,
-        style,
-        // Empty string as style resets to default console style
-        "",
-        ...logObj.args.slice(1)
-      );
-    } else {
-      consoleLogFn(badge, style, ...logObj.args);
-    }
-  }
-}

package/bin/deprecated/components/reporters/fancy.d.ts

@@ -1,10 +0,0 @@
-import type { LogLevelDeprecated, LogTypeDeprecated } from "../../types.js";
-import type { FormatOptions, LogObject } from "../../types.js";
-import { BasicReporter } from "./basic.js";
-export declare const TYPE_COLOR_MAP: Partial<Record<LogTypeDeprecated, string>>;
-export declare const LEVEL_COLOR_MAP: Partial<Record<LogLevelDeprecated, string>>;
-export declare class FancyReporter extends BasicReporter {
-    formatStack(stack: string): string;
-    formatType(logObj: LogObject, isBadge: boolean): any;
-    formatLogObj(logObj: LogObject, opts: FormatOptions): any;
-}

package/bin/deprecated/components/reporters/fancy.js

@@ -1,104 +0,0 @@
-import { isUnicodeSupported } from "@reliverse/runtime";
-import stringWidth from "string-width";
-import { BasicReporter } from "./basic.js";
-import { box } from "../../utils/box.js";
-import { colors } from "../../utils/deprecatedColors.js";
-import { parseStack } from "../../utils/error.js";
-import { stripAnsi } from "../../utils/string.js";
-export const TYPE_COLOR_MAP = {
-  info: "cyan",
-  fail: "red",
-  success: "green",
-  ready: "green",
-  start: "magenta"
-};
-export const LEVEL_COLOR_MAP = {
-  0: "red",
-  1: "yellow"
-};
-const unicode = isUnicodeSupported();
-const s = (c, fallback) => unicode ? c : fallback;
-const TYPE_ICONS = {
-  error: s("\u2716", "\xD7"),
-  fatal: s("\u2716", "\xD7"),
-  ready: s("\u2714", "\u221A"),
-  warn: s("\u26A0", "\u203C"),
-  info: s("\u2139", "i"),
-  success: s("\u2714", "\u221A"),
-  debug: s("\u2699", "D"),
-  trace: s("\u2192", "\u2192"),
-  fail: s("\u2716", "\xD7"),
-  start: s("\u25D0", "o"),
-  log: ""
-};
-function getStringWidth(str) {
-  if (!Intl.Segmenter) {
-    return stripAnsi(str).length;
-  }
-  return stringWidth(str);
-}
-export class FancyReporter extends BasicReporter {
-  formatStack(stack) {
-    return `
-${parseStack(stack).map(
-      (line) => `  ${line.replace(/^at +/, (m) => colors.gray(m)).replace(/\((.+)\)/, (_, m) => `(${colors.cyan(m)})`)}`
-    ).join("\n")}`;
-  }
-  formatType(logObj, isBadge) {
-    const typeColor = TYPE_COLOR_MAP[logObj.type] || LEVEL_COLOR_MAP[logObj.level] || "gray";
-    if (isBadge) {
-      return getBgColor(typeColor)(
-        colors.black(` ${logObj.type.toUpperCase()} `)
-      );
-    }
-    const _type = typeof TYPE_ICONS[logObj.type] === "string" ? TYPE_ICONS[logObj.type] : logObj.icon || logObj.type;
-    return _type ? getColor(typeColor)(_type) : "";
-  }
-  formatLogObj(logObj, opts) {
-    const [message, ...additional] = this.formatArgs(logObj.args, opts).split(
-      "\n"
-    );
-    if (logObj.type === "box") {
-      return box(
-        characterFormat(
-          message + (additional.length > 0 ? `
-${additional.join("\n")}` : "")
-        ),
-        {
-          title: logObj.title ? characterFormat(logObj.title) : void 0,
-          style: logObj.style
-        }
-      );
-    }
-    const date = this.formatDate(logObj.date, opts);
-    const coloredDate = date && colors.gray(date);
-    const isBadge = logObj.badge ?? logObj.level < 2;
-    const type = this.formatType(logObj, isBadge);
-    const tag = logObj.tag ? colors.gray(logObj.tag) : "";
-    let line;
-    const left = this.filterAndJoin([type, characterFormat(message)]);
-    const right = this.filterAndJoin(opts.columns ? [tag, coloredDate] : [tag]);
-    const space = (opts.columns || 0) - getStringWidth(left) - getStringWidth(right) - 2;
-    line = space > 0 && (opts.columns || 0) >= 80 ? left + " ".repeat(space) + right : (right ? `${colors.gray(`[${right}]`)} ` : "") + left;
-    line += characterFormat(
-      additional.length > 0 ? `
-${additional.join("\n")}` : ""
-    );
-    if (logObj.type === "trace") {
-      const _err = new Error(`Trace: ${logObj.message}`);
-      line += this.formatStack(_err.stack || "");
-    }
-    return isBadge ? `
-${line}
-` : line;
-  }
-}
-function characterFormat(str) {
-  return str.replace(/`([^`]+)`/gm, (_, m) => colors.cyan(m)).replace(/\s+_([^_]+)_\s+/gm, (_, m) => ` ${colors.underline(m)} `);
-}
-function getColor(color = "white") {
-  return colors[color] || colors.white;
-}
-function getBgColor(color = "bgWhite") {
-  return colors[`bg${color[0].toUpperCase()}${color.slice(1)}`] || colors.bgWhite;
-}