@visulima/pail 2.1.15 → 2.1.17

package/dist/packem_shared/pail.browser-B3Bi2uPA.cjs

@@ -0,0 +1,387 @@
+'use strict';
+
+const safeStableStringify = require('safe-stable-stringify');
+const constants = require('./constants-DHfYGxxG.cjs');
+const writeConsoleLog = require('./write-console-log-Cu0-IDN-.cjs');
+const getLongestLabel = require('./get-longest-label-CQ7lRhgD.cjs');
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+class RawReporter {
+  static {
+    __name$3(this, "RawReporter");
+  }
+  // eslint-disable-next-line class-methods-use-this
+  log(meta) {
+    const { context = [], message, type } = meta;
+    const consoleLogFunction = writeConsoleLog.writeConsoleLogBasedOnLevel(type.level);
+    consoleLogFunction(message, ...context);
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+const arrayify = /* @__PURE__ */ __name$2((x) => {
+  if (x === undefined) {
+    return [];
+  }
+  return Array.isArray(x) ? x : [x];
+}, "arrayify");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const mergeTypes = /* @__PURE__ */ __name$1((standard, custom) => {
+  const types = { ...standard };
+  Object.keys(custom).forEach((type) => {
+    types[type] = { ...types[type], ...custom[type] };
+  });
+  return types;
+}, "mergeTypes");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class PailBrowserImpl {
+  static {
+    __name(this, "PailBrowserImpl");
+  }
+  timersMap;
+  countMap;
+  seqTimers;
+  lastLog;
+  logLevels;
+  disabled;
+  scopeName;
+  types;
+  longestLabel;
+  processors;
+  generalLogLevel;
+  reporters;
+  throttle;
+  throttleMin;
+  stringify;
+  groups;
+  startTimerMessage;
+  endTimerMessage;
+  rawReporter;
+  constructor(options) {
+    this.throttle = options.throttle ?? 1e3;
+    this.throttleMin = options.throttleMin ?? 5;
+    this.stringify = safeStableStringify.configure({
+      strict: true
+    });
+    this.startTimerMessage = options.messages?.timerStart ?? "Initialized timer...";
+    this.endTimerMessage = options.messages?.timerEnd ?? "Timer run for:";
+    this.types = mergeTypes(constants.LOG_TYPES, options.types ?? {});
+    this.longestLabel = getLongestLabel.getLongestLabel(this.types);
+    this.logLevels = { ...constants.EXTENDED_RFC_5424_LOG_LEVELS, ...options.logLevels };
+    this.generalLogLevel = this._normalizeLogLevel(options.logLevel);
+    this.reporters = /* @__PURE__ */ new Set();
+    this.processors = /* @__PURE__ */ new Set();
+    this.disabled = options.disabled ?? false;
+    this.scopeName = arrayify(options.scope).filter(Boolean);
+    this.timersMap = /* @__PURE__ */ new Map();
+    this.countMap = /* @__PURE__ */ new Map();
+    this.groups = [];
+    this.seqTimers = /* @__PURE__ */ new Set();
+    for (const type in this.types) {
+      this[type] = this._logger.bind(this, type, false);
+    }
+    this.lastLog = {};
+    if (Array.isArray(options.reporters)) {
+      this.registerReporters(options.reporters);
+    }
+    this.rawReporter = this.extendReporter(options.rawReporter ?? new RawReporter());
+    if (Array.isArray(options.processors)) {
+      this.registerProcessors(options.processors);
+    }
+  }
+  wrapConsole() {
+    for (const type in this.types) {
+      if (!console["__" + type]) {
+        console["__" + type] = console[type];
+      }
+      console[type] = this[type];
+    }
+  }
+  restoreConsole() {
+    for (const type in this.types) {
+      if (console["__" + type]) {
+        console[type] = console["__" + type];
+        delete console["__" + type];
+      }
+    }
+  }
+  wrapException() {
+    {
+      process.on("uncaughtException", (error) => {
+        this.error(error);
+      });
+      process.on("unhandledRejection", (error) => {
+        this.error(error);
+      });
+    }
+  }
+  /**
+   * Disables logging
+   */
+  disable() {
+    this.disabled = true;
+  }
+  /**
+   * Enables logging
+   */
+  enable() {
+    this.disabled = false;
+  }
+  isEnabled() {
+    return !this.disabled;
+  }
+  scope(...name) {
+    if (name.length === 0) {
+      throw new Error("No scope name was defined.");
+    }
+    this.scopeName = name.flat();
+    return this;
+  }
+  unscope() {
+    this.scopeName = [];
+  }
+  time(label = "default") {
+    if (this.seqTimers.has(label)) {
+      this._logger("warn", false, {
+        message: "Timer '" + label + "' already exists",
+        prefix: label
+      });
+    } else {
+      this.seqTimers.add(label);
+      this.timersMap.set(label, Date.now());
+      this._logger("start", false, {
+        message: this.startTimerMessage,
+        prefix: label
+      });
+    }
+  }
+  timeLog(label, ...data) {
+    if (!label && this.seqTimers.size > 0) {
+      label = [...this.seqTimers].pop();
+    }
+    if (label && this.timersMap.has(label)) {
+      const span = Date.now() - this.timersMap.get(label);
+      this._logger("info", false, {
+        context: data,
+        message: span < 1e3 ? span + " ms" : (span / 1e3).toFixed(2) + " s",
+        prefix: label
+      });
+    } else {
+      this._logger("warn", false, {
+        context: data,
+        message: "Timer not found",
+        prefix: label
+      });
+    }
+  }
+  timeEnd(label) {
+    if (!label && this.seqTimers.size > 0) {
+      label = [...this.seqTimers].pop();
+    }
+    if (label && this.timersMap.has(label)) {
+      const span = Date.now() - this.timersMap.get(label);
+      this.timersMap.delete(label);
+      this._logger("stop", false, {
+        message: this.endTimerMessage + " " + (span < 1e3 ? span + " ms" : (span / 1e3).toFixed(2) + " s"),
+        prefix: label
+      });
+    } else {
+      this._logger("warn", false, {
+        message: "Timer not found",
+        prefix: label
+      });
+    }
+  }
+  group(label = "console.group") {
+    if (typeof window === "undefined") {
+      this.groups.push(label);
+    } else {
+      console.group(label);
+    }
+  }
+  groupEnd() {
+    if (typeof window === "undefined") {
+      this.groups.pop();
+    } else {
+      console.groupEnd();
+    }
+  }
+  count(label = "default") {
+    const current = this.countMap.get(label) ?? 0;
+    this.countMap.set(label, current + 1);
+    this._logger("log", false, {
+      message: label + ": " + (current + 1),
+      prefix: label
+    });
+  }
+  countReset(label = "default") {
+    if (this.countMap.has(label)) {
+      this.countMap.delete(label);
+    } else {
+      this._logger("warn", false, {
+        message: "Count for " + label + " does not exist",
+        prefix: label
+      });
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this
+  clear() {
+    console.clear();
+  }
+  raw(message, ...arguments_) {
+    if (this.disabled) {
+      return;
+    }
+    this._logger("log", true, {
+      context: arguments_,
+      message
+    });
+  }
+  extendReporter(reporter) {
+    if (typeof reporter.setLoggerTypes === "function") {
+      reporter.setLoggerTypes(this.types);
+    }
+    if (typeof reporter.setStringify === "function") {
+      reporter.setStringify(this.stringify);
+    }
+    return reporter;
+  }
+  registerReporters(reporters) {
+    for (const reporter of reporters) {
+      this.reporters.add(this.extendReporter(reporter));
+    }
+  }
+  _report(meta, raw) {
+    if (raw) {
+      this.rawReporter.log(Object.freeze(meta));
+    } else {
+      for (const reporter of this.reporters) {
+        reporter.log(Object.freeze(meta));
+      }
+    }
+  }
+  registerProcessors(processors) {
+    for (const processor of processors) {
+      if (typeof processor.setStringify === "function") {
+        processor.setStringify(this.stringify);
+      }
+      this.processors.add(processor);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  _normalizeLogLevel(level) {
+    return level && this.logLevels[level] ? level : "debug";
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity,@typescript-eslint/no-explicit-any
+  _buildMeta(typeName, type, ...arguments_) {
+    const meta = {
+      badge: undefined,
+      context: undefined,
+      error: undefined,
+      label: undefined,
+      message: constants.EMPTY_SYMBOL,
+      prefix: undefined,
+      repeated: undefined,
+      scope: undefined,
+      suffix: undefined
+    };
+    meta.type = {
+      level: type.logLevel,
+      name: typeName
+    };
+    meta.groups = this.groups;
+    meta.scope = this.scopeName;
+    meta.date = /* @__PURE__ */ new Date();
+    if (arguments_.length === 1 && typeof arguments_[0] === "object" && arguments_[0] !== null) {
+      if (arguments_[0] instanceof Error) {
+        meta.error = arguments_[0];
+      } else if ("message" in arguments_[0]) {
+        const { context, message, prefix, suffix } = arguments_[0];
+        if (context) {
+          meta.context = context;
+        }
+        if (prefix) {
+          meta.prefix = prefix;
+        }
+        if (suffix) {
+          meta.suffix = suffix;
+        }
+        meta.message = message;
+      } else {
+        meta.message = arguments_[0];
+      }
+    } else if (arguments_.length > 1 && typeof arguments_[0] === "string") {
+      meta.message = arguments_[0];
+      meta.context = arguments_.slice(1);
+    } else {
+      meta.message = arguments_[0];
+    }
+    if (type.logLevel === "trace") {
+      meta.traceError = new Error("Trace");
+    }
+    if (type.badge) {
+      meta.badge = type.badge;
+    }
+    if (type.label) {
+      meta.label = type.label;
+    }
+    return meta;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity,@typescript-eslint/no-explicit-any
+  _logger(type, raw, ...messageObject) {
+    if (this.disabled) {
+      return;
+    }
+    const logLevel = this._normalizeLogLevel(this.types[type].logLevel);
+    if (this.logLevels[logLevel] >= this.logLevels[this.generalLogLevel]) {
+      let meta = this._buildMeta(type, this.types[type], ...messageObject);
+      const resolveLog = /* @__PURE__ */ __name((newLog = false) => {
+        const repeated = (this.lastLog.count || 0) - this.throttleMin;
+        if (this.lastLog.object && repeated > 0) {
+          const lastMeta = { ...this.lastLog.object };
+          if (repeated > 1) {
+            lastMeta.repeated = repeated;
+          }
+          this._report(lastMeta, raw);
+          this.lastLog.count = 1;
+        }
+        if (newLog) {
+          for (const processor of this.processors) {
+            meta = { ...processor.process(meta) };
+          }
+          this.lastLog.object = meta;
+          this._report(meta, raw);
+        }
+      }, "resolveLog");
+      clearTimeout(this.lastLog.timeout);
+      const diffTime = this.lastLog.time && meta.date ? new Date(meta.date).getTime() - this.lastLog.time.getTime() : 0;
+      this.lastLog.time = new Date(meta.date);
+      if (diffTime < this.throttle) {
+        try {
+          const serializedLog = JSON.stringify([meta.label, meta.scope, meta.type, meta.message, meta.prefix, meta.suffix, meta.context]);
+          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.throttleMin) {
+              this.lastLog.timeout = setTimeout(resolveLog, this.throttle);
+              return;
+            }
+          }
+        } catch {
+        }
+      }
+      resolveLog(true);
+    }
+  }
+}
+const PailBrowser = PailBrowserImpl;
+
+exports.PailBrowser = PailBrowser;
+exports.PailBrowserImpl = PailBrowserImpl;