@coursebuilder/core/dist/lib/utils/logger.cjs

Core package for Course Builder

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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);
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};

// src/lib/utils/logger.ts
var logger_exports = {};
__export(logger_exports, {
  logger: () => logger,
  setLogger: () => setLogger
});
module.exports = __toCommonJS(logger_exports);

// src/errors.ts
var _CourseBuilderError = class _CourseBuilderError extends Error {
  constructor(message, errorOptions) {
    var __super = (...args) => {
      super(...args);
      /** The error type. Used to identify the error in the logs. */
      __publicField(this, "type");
      /**
      * Determines on which page an error should be handled. Typically `signIn` errors can be handled in-page.
      * Default is `"error"`.
      * @internal
      */
      __publicField(this, "kind");
      __publicField(this, "cause");
      return this;
    };
    if (message instanceof Error) {
      __super(void 0, {
        cause: {
          err: message,
          ...message.cause,
          ...errorOptions
        }
      });
    } else if (typeof message === "string") {
      if (errorOptions instanceof Error) {
        errorOptions = {
          err: errorOptions,
          ...errorOptions.cause
        };
      }
      __super(message, errorOptions);
    } else {
      __super(void 0, message);
    }
    this.name = this.constructor.name;
    this.type = this.constructor.type ?? "CourseBuilderError";
    this.kind = this.constructor.kind ?? "error";
    Error.captureStackTrace?.(this, this.constructor);
    const url = `https://errors.authjs.dev#${this.type.toLowerCase()}`;
    this.message += `${this.message ? ". " : ""}Read more at ${url}`;
  }
};
__name(_CourseBuilderError, "CourseBuilderError");
var CourseBuilderError = _CourseBuilderError;

// src/lib/utils/logger.ts
var red = "\x1B[31m";
var yellow = "\x1B[33m";
var grey = "\x1B[38;5;246m";
var reset = "\x1B[0m";
var logger = {
  error(error) {
    const name = error instanceof CourseBuilderError ? error.type : error.name;
    console.error(`${red}[coursebuilder][error]${reset} ${name}: ${error.message}`);
    if (error.cause && typeof error.cause === "object" && "err" in error.cause && error.cause.err instanceof Error) {
      const { err, ...data } = error.cause;
      console.error(`${red}[coursebuilder][cause]${reset}:`, err.stack);
      if (data)
        console.error(`${red}[coursebuilder][details]${reset}:`, JSON.stringify(data, null, 2));
    } else if (error.stack) {
      console.error(error.stack.replace(/.*/, "").substring(1));
    }
  },
  warn(code) {
    const url = `https://warnings.coursebuilder.dev#${code}`;
    console.warn(`${yellow}[coursebuilder][warn][${code}]${reset}`, `Read more: ${url}`);
  },
  debug(message, metadata) {
    console.log(`${grey}[coursebuilder][debug]:${reset} ${message}`, JSON.stringify(metadata, null, 2));
  }
};
function setLogger(newLogger = {}, debug) {
  if (!debug)
    logger.debug = () => {
    };
  if (newLogger.error)
    logger.error = newLogger.error;
  if (newLogger.warn)
    logger.warn = newLogger.warn;
  if (newLogger.debug)
    logger.debug = newLogger.debug;
}
__name(setLogger, "setLogger");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  logger,
  setLogger
});
//# sourceMappingURL=logger.cjs.map