@plugjs/plug/dist/logging/logger.cjs

PlugJS Build System ===================

"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// logging/logger.ts
var logger_exports = {};
__export(logger_exports, {
  TestLogger: () => TestLogger,
  getLogger: () => getLogger
});
module.exports = __toCommonJS(logger_exports);
var import_node_util = require("node:util");
var import_asserts = require("../asserts.cjs");
var import_async = require("../async.cjs");
var import_ansi = require("../utils/ansi.cjs");
var import_colors = require("./colors.cjs");
var import_emit = require("./emit.cjs");
var import_levels = require("./levels.cjs");
var import_options = require("./options.cjs");
var import_report = require("./report.cjs");
var _level = import_options.logOptions.level;
import_options.logOptions.on("changed", ({ level }) => {
  _level = level;
});
function getLogger(task, indent) {
  const context = (0, import_async.currentContext)();
  const taskName = task === void 0 ? context?.taskName || "" : task;
  const indentLevel = indent === void 0 ? context?.log.indent || 0 : 0;
  return new LoggerImpl(taskName, import_emit.emit, indentLevel);
}
var _loggedFailures = /* @__PURE__ */ new WeakSet();
var LoggerImpl = class {
  constructor(_task, _emitter, indent) {
    this._task = _task;
    this._emitter = _emitter;
    this.indent = indent;
  }
  _stack = [];
  level = _level;
  _emit(level, args, taskName = this._task) {
    if (this.level > level) return;
    const params = args.filter((arg) => {
      if (arg instanceof import_asserts.BuildFailure) {
        if (_loggedFailures.has(arg)) return false;
        _loggedFailures.add(arg);
        arg.errors?.forEach((error) => this._emit(level, [error]));
        if (!arg.message) return false;
        if (_level < import_levels.INFO) return true;
        this._emit(level, [arg.message]);
        return false;
      } else {
        return true;
      }
    });
    if (params.length === 0) return;
    const options = { level, taskName, indent: this.indent };
    if (this._stack.length) {
      for (const { message, ...extras } of this._stack) {
        this._emitter({ ...options, ...extras }, [message]);
      }
      this._stack.splice(0);
    }
    this._emitter(options, params);
  }
  trace(...args) {
    this._emit(import_levels.TRACE, args);
  }
  debug(...args) {
    this._emit(import_levels.DEBUG, args);
  }
  info(...args) {
    this._emit(import_levels.INFO, args);
  }
  notice(...args) {
    this._emit(import_levels.NOTICE, args);
  }
  warn(...args) {
    this._emit(import_levels.WARN, args);
  }
  error(...args) {
    this._emit(import_levels.ERROR, args);
  }
  fail(...args) {
    this._emit(import_levels.ERROR, args);
    throw import_asserts.BuildFailure.fail();
  }
  enter(...args) {
    if (args.length) {
      const [level, message] = args;
      this._stack.push({ level, message, indent: this.indent });
    }
    this.indent++;
  }
  leave(...args) {
    this._stack.pop();
    this.indent--;
    if (this.indent < 0) this.indent = 0;
    if (args.length) {
      const [level, message] = args;
      this._emit(level, [message]);
    }
  }
  report(title) {
    const emitter = (options, args) => {
      if (this._stack.length) {
        for (const { message, ...extras } of this._stack) {
          this._emitter({ ...options, ...extras }, [message]);
        }
        this._stack.splice(0);
      }
      let { indent = 0, prefix = "" } = options;
      prefix = this.indent ? (0, import_colors.$gry)("| ") + prefix : prefix;
      indent += this.indent;
      this._emitter({ ...options, indent, prefix }, args);
    };
    return new import_report.ReportImpl(title, this._task, emitter);
  }
};
var TestLogger = class extends LoggerImpl {
  _lines = [];
  constructor() {
    super("", (options, args) => {
      const { prefix = "", indent = 0 } = options;
      const linePrefix = "".padStart(indent * 2) + prefix;
      (0, import_node_util.formatWithOptions)({ colors: false, breakLength: 120 }, ...args).split("\n").forEach((line) => {
        const stripped = (0, import_ansi.stripAnsi)(line);
        this._lines.push(`${linePrefix}${stripped}`);
      });
    }, 0);
  }
  /** Return the _current_ buffer for this instance */
  get buffer() {
    return this._lines.join("\n");
  }
  /** Reset the buffer and return any previously buffered text */
  reset() {
    const buffer = this.buffer;
    this._lines = [];
    return buffer;
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  TestLogger,
  getLogger
});
//# sourceMappingURL=logger.cjs.map