@warlock.js/logger 4.0.39 → 4.0.41

package/esm/index.js

@@ -1,3 +1,674 @@
-import {colors}from'@mongez/copper';import {ensureDirectoryAsync,fileExistsAsync,getJsonFileAsync,putJsonFileAsync}from'@mongez/fs';import u from'dayjs';import L from'fs';import {EOL}from'os';import f from'path';import {Random}from'@mongez/reinforcements';var h=class{name;description;terminal=false;defaultConfigurations={};channelConfigurations={};isInitialized=false;constructor(e){e&&this.setConfigurations(e),setTimeout(async()=>{this.init&&await this.init(),this.isInitialized=true;},0);}config(e){return this.channelConfigurations[e]??(this.defaultConfigurations??{})[e]}setConfigurations(e){return this.channelConfigurations={...this.channelConfigurations,...e},this}shouldBeLogged(e){let t=this.config("levels");if(t?.length&&!t.includes(e.type))return  false;let s=this.config("filter");return s?s(e):true}getDateAndTimeFormat(){let e=this.config("dateFormat"),t=e?.date??"DD-MM-YYYY",s=e?.time??"HH:mm:ss";return {date:t,time:s}}withBasicConfigurations(e){return {filter:()=>true,...e}}};var x=class extends h{name="console";terminal=true;log(e){let{module:t,action:s,message:i,type:r}=e;if(!this.shouldBeLogged(e))return;let a=new Date().toISOString();switch(r){case "debug":console.log(colors.magentaBright("\u2699"),colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),colors.magentaBright(i));break;case "info":console.log(colors.blueBright("\u2139"),colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),colors.blueBright(i));break;case "warn":console.log(colors.yellow("\u26A0"),colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),colors.yellowBright(i));break;case "error":console.log(colors.red("\u2717"),colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),colors.redBright(i));break;case "success":console.log(colors.green("\u2713"),colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),colors.greenBright(i));break;default:console.log("[log]",colors.yellow(`(${a})`),colors.cyan(`[${t}]`),colors.magenta(`[${s}]`),i);}typeof i=="object"&&console.log(i);}};var d=class extends h{name="file";messages=[];groupedMessages={};defaultConfigurations={storagePath:process.cwd()+"/storage/logs",rotate:true,name:"app",extension:"log",chunk:"single",maxMessagesToWrite:100,filter:()=>true,maxFileSize:10*1024*1024,get rotateFileName(){return u().format("DD-MM-YYYY")},dateFormat:{date:"DD-MM-YYYY",time:"HH:mm:ss"}};lastWriteTime=Date.now();isWriting=false;async checkAndRotateFile(e=this.filePath){if(this.config("rotate"))try{(await L.promises.stat(e)).size>=this.config("maxFileSize")&&await this.rotateLogFile();}catch(t){t.code==="ENOENT"?console.log("Log file does not exist, will be created on first write."):console.error("Error checking log file:",t);}}async rotateLogFile(){let e=`${this.fileName}-${this.config("rotateFileName")}-${Date.now()}`,t=this.extension,s=f.join(this.storagePath,`${e}.${t}`);await L.promises.rename(this.filePath,s).catch(i=>{console.error("Error rotating file:",i);});}initMessageFlush(){setInterval(()=>{this.messages.length>0&&(this.messages.length>=this.maxMessagesToWrite||Date.now()-this.lastWriteTime>5e3)&&this.writeMessagesToFile();},5e3);}get filePath(){let e=this.fileName,t=this.extension;return f.join(this.storagePath,`${e}.${t}`)}get maxMessagesToWrite(){return this.config("maxMessagesToWrite")}get fileName(){switch(this.config("chunk")){case "single":default:return this.config("name");case "daily":return u().format("DD-MM-YYYY");case "hourly":return u().format("DD-MM-YYYY-HH")}}get extension(){return this.config("extension")}get content(){return this.messages.map(e=>e.content).join(EOL)+EOL}get storagePath(){return this.config("storagePath")}async init(){let e=this.storagePath;await ensureDirectoryAsync(e),this.initMessageFlush();}async log(e){let{module:t,action:s,message:i,type:r}=e;if(!this.shouldBeLogged(e))return;let{date:a,time:y}=this.getDateAndTimeFormat(),m=u().format(a+" "+y),l=`[${m}] [${r}] [${t}][${s}]: `,b;i instanceof Error?(l+=i.message+EOL,l+="[trace]"+EOL,l+=i.stack,b=i.stack):l+=i,this.messages.push({content:l,level:r,date:m,module:t,action:s,stack:b}),await this.checkIfMessagesShouldBeWritten();}async checkIfMessagesShouldBeWritten(){(this.messages.length>=this.maxMessagesToWrite||Date.now()-this.lastWriteTime>5e3)&&await this.writeMessagesToFile();}onSave(){this.messages=[],this.groupedMessages={},this.isWriting=false,this.lastWriteTime=Date.now();}get messagedShouldBeGrouped(){return Number(this.config("groupBy")?.length)>0}async writeMessagesToFile(){if(!(this.messages.length===0||this.isWriting||!this.isInitialized)){if(this.isWriting=true,this.messagedShouldBeGrouped)return await this.writeGroupedMessagesToFile();await this.checkAndRotateFile();try{await this.write(this.filePath,this.content),this.onSave();}catch(e){console.error("Failed to write log:",e),this.isWriting=false;}}}async writeGroupedMessagesToFile(){this.prepareGroupedMessages();for(let e in this.groupedMessages){let t=f.join(this.storagePath,e);await ensureDirectoryAsync(t);let s=f.join(t,`${this.fileName}.${this.extension}`);await this.checkAndRotateFile(s);let i=this.groupedMessages[e].map(r=>r.content).join(EOL)+EOL;try{await this.write(s,i);}catch(r){console.error("Failed to write log:",r);}}this.onSave(),this.isWriting=false;}prepareGroupedMessages(){this.messages.forEach(e=>{let t=this.config("groupBy").map(s=>encodeURIComponent(e[s])).join("/");this.groupedMessages[t]=this.groupedMessages[t]||[],this.groupedMessages[t].push(e);});}async write(e,t){return new Promise((s,i)=>{let r=L.createWriteStream(e,{flags:"a"});r.write(t,a=>{r.end(),a?i(a):s(true);});})}};var C=class extends d{name="fileJson";get extension(){return "json"}get initialFileContents(){return {messages:this.messages}}async log(e){let t;e.message instanceof Error&&(t=e.message.stack?.split(`
-`),e.message=e.message.message);let{module:s,action:i,message:r,type:a}=e;if(!this.shouldBeLogged(e))return;let{date:y,time:m}=this.getDateAndTimeFormat(),l=u().format(y+" "+m);this.messages.push({content:r,level:a,date:l,module:s,action:i,stack:t}),await this.checkIfMessagesShouldBeWritten();}async writeMessagesToFile(){if(this.messages.length===0||this.isWriting)return;if(this.isWriting=true,this.messagedShouldBeGrouped)return await this.writeGroupedMessagesToFile();await this.checkAndRotateFile();let e;if(await fileExistsAsync(this.filePath))try{e=await getJsonFileAsync(this.filePath);}catch(t){console.error("Error reading log file, reinitializing:",t),e={messages:[]};}else e={messages:[]};e.messages.push(...this.messages);try{await putJsonFileAsync(this.filePath,e,{spaces:2}),this.onSave();}catch(t){console.error("Failed to write log:",t),this.isWriting=false;}}async writeGroupedMessagesToFile(){this.prepareGroupedMessages();for(let e in this.groupedMessages){let t=f.join(this.storagePath,e);await ensureDirectoryAsync(t);let s=f.join(t,`${this.fileName}.${this.extension}`);await this.checkAndRotateFile(s);let i=this.groupedMessages[e];try{await putJsonFileAsync(s,i,{spaces:2});}catch(r){console.error("Failed to write log:",r),this.isWriting=false;}}this.onSave();}};function $(n){return typeof n!="string"?n:n.replace(/\u001b[^m]*?m/g,"")}var w=class{channels=[];id="logger-"+Random.string(32);addChannel(e){return this.channels.push(e),this}configure(e){return this.channels=e.channels,this}setChannels(e){return this.channels=e,this}normalizeLogData(e,t,s="",i){return typeof e=="object"?{type:i||e.type||"info",module:e.module,action:e.action,message:e.message,...e.context?{context:e.context}:{}}:{type:i||"info",module:e,action:t,message:s}}async log(e){for(let t of this.channels)t.terminal===false&&(e.message=$(e.message)),t.log(e);return this}debug(e,t,s=""){let i=this.normalizeLogData(e,t,s,"debug");return this.log(i)}info(e,t,s=""){let i=this.normalizeLogData(e,t,s,"info");return this.log(i)}warn(e,t,s=""){let i=this.normalizeLogData(e,t,s,"warn");return this.log(i)}error(e,t,s=""){let i=this.normalizeLogData(e,t,s,"error");return this.log(i)}success(e,t,s=""){let i=this.normalizeLogData(e,t,s,"success");return this.log(i)}channel(e){return this.channels.find(t=>t.name===e)}},g=new w,c=n=>g.log(n);c.info=g.info.bind(g);c.debug=g.debug.bind(g);c.warn=g.warn.bind(g);c.error=g.error.bind(g);c.success=g.success.bind(g);c.channel=g.channel.bind(g);function ie(){process.on("unhandledRejection",(n,e)=>{c.error("app","unhandledRejection",n),console.log(e);}),process.on("uncaughtException",n=>{c.error("app","uncaughtException",n),console.log(n);});}export{x as ConsoleLog,d as FileLog,C as JSONFileLog,h as LogChannel,w as Logger,ie as captureAnyUnhandledRejection,$ as clearMessage,c as log,g as logger};//# sourceMappingURL=index.js.map
+import { colors } from '@mongez/copper';
+import { ensureDirectoryAsync, fileExistsAsync, getJsonFileAsync, putJsonFileAsync } from '@mongez/fs';
+import dayjs from 'dayjs';
+import fs from 'fs';
+import { EOL } from 'os';
+import path from 'path';
+import { Random } from '@mongez/reinforcements';
+
+// ../../warlock.js/logger/src/channels/console-log.ts
+
+// ../../warlock.js/logger/src/log-channel.ts
+var LogChannel = class {
+  /**
+   * Channel name
+   */
+  name;
+  /**
+   * Channel description
+   */
+  description;
+  /**
+   * Determine if channel is logging in terminal
+   */
+  terminal = false;
+  /**
+   * Default Configurations
+   */
+  defaultConfigurations = {};
+  /**
+   * Channel configurations
+   */
+  channelConfigurations = {};
+  //
+  /**
+   * Determine whether the channel is fully initialized
+   */
+  isInitialized = false;
+  /**
+   * Constructor
+   */
+  constructor(configurations) {
+    if (configurations) {
+      this.setConfigurations(configurations);
+    }
+    setTimeout(async () => {
+      if (this.init) {
+        await this.init();
+      }
+      this.isInitialized = true;
+    }, 0);
+  }
+  /**
+   * Get config value
+   */
+  config(key) {
+    return this.channelConfigurations[key] ?? (this.defaultConfigurations ?? {})[key];
+  }
+  /**
+   * Set configurations
+   */
+  setConfigurations(configurations) {
+    this.channelConfigurations = {
+      ...this.channelConfigurations,
+      ...configurations
+    };
+    return this;
+  }
+  /**
+   * Determine if the message should be logged
+   */
+  shouldBeLogged(data) {
+    const allowedLevels = this.config("levels");
+    if (allowedLevels?.length && !allowedLevels.includes(data.type))
+      return false;
+    const filter = this.config("filter");
+    if (filter) {
+      return filter(data);
+    }
+    return true;
+  }
+  /**
+   * Get date and time formats
+   */
+  getDateAndTimeFormat() {
+    const dateFormat = this.config("dateFormat");
+    const date = dateFormat?.date ?? "DD-MM-YYYY";
+    const time = dateFormat?.time ?? "HH:mm:ss";
+    return { date, time };
+  }
+  /**
+   * get basic configurations with the given ones
+   */
+  withBasicConfigurations(configurations) {
+    return {
+      filter: () => true,
+      ...configurations
+    };
+  }
+};
+
+// ../../warlock.js/logger/src/channels/console-log.ts
+var ConsoleLog = class extends LogChannel {
+  /**
+   * {@inheritdoc}
+   */
+  name = "console";
+  /**
+   * Determine if channel is logging in terminal
+   */
+  terminal = true;
+  /**
+   * {@inheritdoc}
+   */
+  log(data) {
+    const { module, action, message, type: level } = data;
+    if (!this.shouldBeLogged(data)) return;
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    switch (level) {
+      case "debug":
+        console.log(
+          colors.magentaBright("\u2699"),
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          colors.magentaBright(message)
+        );
+        break;
+      case "info":
+        console.log(
+          colors.blueBright("\u2139"),
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          colors.blueBright(message)
+        );
+        break;
+      case "warn":
+        console.log(
+          colors.yellow("\u26A0"),
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          colors.yellowBright(message)
+        );
+        break;
+      case "error":
+        console.log(
+          colors.red("\u2717"),
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          colors.redBright(message)
+        );
+        break;
+      case "success":
+        console.log(
+          colors.green("\u2713"),
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          colors.greenBright(message)
+        );
+        break;
+      default:
+        console.log(
+          "[log]",
+          colors.yellow(`(${date})`),
+          colors.cyan(`[${module}]`),
+          colors.magenta(`[${action}]`),
+          message
+        );
+    }
+    if (typeof message === "object") {
+      console.log(message);
+    }
+  }
+};
+var FileLog = class extends LogChannel {
+  /**
+   * {@inheritdoc}
+   */
+  name = "file";
+  /**
+   * Messages buffer
+   */
+  messages = [];
+  /**
+   * Grouped messages
+   */
+  groupedMessages = {};
+  /**
+   * Default channel configurations
+   */
+  defaultConfigurations = {
+    storagePath: process.cwd() + "/storage/logs",
+    rotate: true,
+    name: "app",
+    extension: "log",
+    chunk: "single",
+    maxMessagesToWrite: 100,
+    filter: () => true,
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    get rotateFileName() {
+      return dayjs().format("DD-MM-YYYY");
+    },
+    dateFormat: {
+      date: "DD-MM-YYYY",
+      time: "HH:mm:ss"
+    }
+  };
+  /**
+   * Last write time
+   */
+  lastWriteTime = Date.now();
+  /**
+   * A flag to determine if the file is being written
+   */
+  isWriting = false;
+  /**
+   * Check file size for file rotation
+   */
+  async checkAndRotateFile(filePath = this.filePath) {
+    if (!this.config("rotate")) return;
+    try {
+      const stats = await fs.promises.stat(filePath);
+      if (stats.size >= this.config("maxFileSize")) {
+        await this.rotateLogFile();
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.log("Log file does not exist, will be created on first write.");
+      } else {
+        console.error("Error checking log file:", error);
+      }
+    }
+  }
+  /**
+   * Rotate log file
+   */
+  async rotateLogFile() {
+    const fileName = `${this.fileName}-${this.config(
+      "rotateFileName"
+    )}-${Date.now()}`;
+    const extension = this.extension;
+    const rotatedFilePath = path.join(
+      this.storagePath,
+      `${fileName}.${extension}`
+    );
+    await fs.promises.rename(this.filePath, rotatedFilePath).catch((error) => {
+      console.error("Error rotating file:", error);
+    });
+  }
+  /**
+   * Flush messages
+   */
+  initMessageFlush() {
+    setInterval(() => {
+      if (this.messages.length > 0 && (this.messages.length >= this.maxMessagesToWrite || Date.now() - this.lastWriteTime > 5e3)) {
+        this.writeMessagesToFile();
+      }
+    }, 5e3);
+  }
+  /**
+   * Get file path
+   */
+  get filePath() {
+    const fileName = this.fileName;
+    const extension = this.extension;
+    return path.join(this.storagePath, `${fileName}.${extension}`);
+  }
+  /**
+   * Get max messages
+   */
+  get maxMessagesToWrite() {
+    return this.config("maxMessagesToWrite");
+  }
+  /**
+   * Get file name
+   */
+  get fileName() {
+    const debugLevel = this.config("chunk");
+    switch (debugLevel) {
+      case "single":
+      default:
+        return this.config("name");
+      case "daily":
+        return dayjs().format("DD-MM-YYYY");
+      case "hourly":
+        return dayjs().format("DD-MM-YYYY-HH");
+    }
+  }
+  /**
+   * Get file extension
+   */
+  get extension() {
+    return this.config("extension");
+  }
+  /**
+   * Get content
+   */
+  get content() {
+    return this.messages.map((message) => message.content).join(EOL) + EOL;
+  }
+  /**
+   * Get storage path
+   */
+  get storagePath() {
+    return this.config("storagePath");
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async init() {
+    const logsDirectory = this.storagePath;
+    await ensureDirectoryAsync(logsDirectory);
+    this.initMessageFlush();
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async log(data) {
+    const { module, action, message, type: level } = data;
+    if (!this.shouldBeLogged(data)) return;
+    const { date: dateFormat, time } = this.getDateAndTimeFormat();
+    const date = dayjs().format(dateFormat + " " + time);
+    let content = `[${date}] [${level}] [${module}][${action}]: `;
+    let stack;
+    if (message instanceof Error) {
+      content += message.message + EOL;
+      content += `[trace]` + EOL;
+      content += message.stack;
+      stack = message.stack;
+    } else {
+      content += message;
+    }
+    this.messages.push({
+      content,
+      level,
+      date,
+      module,
+      action,
+      stack
+    });
+    await this.checkIfMessagesShouldBeWritten();
+  }
+  /**
+   * Check if messages should be written
+   */
+  async checkIfMessagesShouldBeWritten() {
+    if (this.messages.length >= this.maxMessagesToWrite || Date.now() - this.lastWriteTime > 5e3) {
+      await this.writeMessagesToFile();
+    }
+  }
+  /**
+   * Should be called after messages are saved
+   */
+  onSave() {
+    this.messages = [];
+    this.groupedMessages = {};
+    this.isWriting = false;
+    this.lastWriteTime = Date.now();
+  }
+  /**
+   * Check if messages should be grouped
+   */
+  get messagedShouldBeGrouped() {
+    return Number(this.config("groupBy")?.length) > 0;
+  }
+  /**
+   * Write messages to the file
+   */
+  async writeMessagesToFile() {
+    if (this.messages.length === 0 || this.isWriting || !this.isInitialized)
+      return;
+    this.isWriting = true;
+    if (this.messagedShouldBeGrouped) {
+      return await this.writeGroupedMessagesToFile();
+    }
+    await this.checkAndRotateFile();
+    try {
+      await this.write(this.filePath, this.content);
+      this.onSave();
+    } catch (error) {
+      console.error("Failed to write log:", error);
+      this.isWriting = false;
+    }
+  }
+  /**
+   * Write grouped messages to the file
+   */
+  async writeGroupedMessagesToFile() {
+    this.prepareGroupedMessages();
+    for (const key in this.groupedMessages) {
+      const directoryPath = path.join(this.storagePath, key);
+      await ensureDirectoryAsync(directoryPath);
+      const filePath = path.join(
+        directoryPath,
+        `${this.fileName}.${this.extension}`
+      );
+      await this.checkAndRotateFile(filePath);
+      const content = this.groupedMessages[key].map((message) => message.content).join(EOL) + EOL;
+      try {
+        await this.write(filePath, content);
+      } catch (error) {
+        console.error("Failed to write log:", error);
+      }
+    }
+    this.onSave();
+    this.isWriting = false;
+  }
+  /**
+   * Prepare grouped messages
+   */
+  prepareGroupedMessages() {
+    this.messages.forEach((message) => {
+      const key = this.config("groupBy").map((groupKey) => encodeURIComponent(message[groupKey])).join("/");
+      this.groupedMessages[key] = this.groupedMessages[key] || [];
+      this.groupedMessages[key].push(message);
+    });
+  }
+  /**
+   * Start writing to the file
+   */
+  async write(filePath, content) {
+    return new Promise((resolve, reject) => {
+      const writer = fs.createWriteStream(filePath, { flags: "a" });
+      writer.write(content, (error) => {
+        writer.end();
+        if (error) {
+          reject(error);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+};
+var JSONFileLog = class extends FileLog {
+  /**
+   * {@inheritdoc}
+   */
+  name = "fileJson";
+  /**
+   * Get file extension
+   */
+  get extension() {
+    return "json";
+  }
+  /**
+   * Get initial file contents
+   */
+  get initialFileContents() {
+    return {
+      messages: this.messages
+    };
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async log(data) {
+    let stack;
+    if (data.message instanceof Error) {
+      stack = data.message.stack?.split("\n");
+      data.message = data.message.message;
+    }
+    const { module, action, message, type: level } = data;
+    if (!this.shouldBeLogged(data)) return;
+    const { date: dateFormat, time } = this.getDateAndTimeFormat();
+    const date = dayjs().format(dateFormat + " " + time);
+    this.messages.push({
+      content: message,
+      level,
+      date,
+      module,
+      action,
+      stack
+    });
+    await this.checkIfMessagesShouldBeWritten();
+  }
+  /**
+   * Write messages to the file
+   */
+  async writeMessagesToFile() {
+    if (this.messages.length === 0 || this.isWriting) return;
+    this.isWriting = true;
+    if (this.messagedShouldBeGrouped) {
+      return await this.writeGroupedMessagesToFile();
+    }
+    await this.checkAndRotateFile();
+    let fileContents;
+    if (await fileExistsAsync(this.filePath)) {
+      try {
+        fileContents = await getJsonFileAsync(this.filePath);
+      } catch (error) {
+        console.error("Error reading log file, reinitializing:", error);
+        fileContents = { messages: [] };
+      }
+    } else {
+      fileContents = { messages: [] };
+    }
+    fileContents.messages.push(...this.messages);
+    try {
+      await putJsonFileAsync(this.filePath, fileContents, { spaces: 2 });
+      this.onSave();
+    } catch (error) {
+      console.error("Failed to write log:", error);
+      this.isWriting = false;
+    }
+  }
+  /**
+   * Write grouped messages to the file
+   */
+  async writeGroupedMessagesToFile() {
+    this.prepareGroupedMessages();
+    for (const key in this.groupedMessages) {
+      const directoryPath = path.join(this.storagePath, key);
+      await ensureDirectoryAsync(directoryPath);
+      const filePath = path.join(
+        directoryPath,
+        `${this.fileName}.${this.extension}`
+      );
+      await this.checkAndRotateFile(filePath);
+      const content = this.groupedMessages[key];
+      try {
+        await putJsonFileAsync(filePath, content, { spaces: 2 });
+      } catch (error) {
+        console.error("Failed to write log:", error);
+        this.isWriting = false;
+      }
+    }
+    this.onSave();
+  }
+};
+
+// ../../warlock.js/logger/src/utils/clear-message.ts
+function clearMessage(message) {
+  if (typeof message !== "string") return message;
+  return message.replace(/\u001b[^m]*?m/g, "");
+}
+
+// ../../warlock.js/logger/src/logger.ts
+var Logger = class {
+  /**
+   * Current channel
+   */
+  channels = [];
+  id = "logger-" + Random.string(32);
+  /**
+   * Add a new channel
+   */
+  addChannel(channel) {
+    this.channels.push(channel);
+    return this;
+  }
+  /**
+   * Set base configurations
+   */
+  configure(config) {
+    this.channels = config.channels;
+    return this;
+  }
+  /**
+   * Set channels
+   */
+  setChannels(channels) {
+    this.channels = channels;
+    return this;
+  }
+  /**
+   * Normalize log data to a single object
+   */
+  normalizeLogData(dataOrModule, action, message = "", level) {
+    if (typeof dataOrModule === "object") {
+      return {
+        type: level || dataOrModule.type || "info",
+        module: dataOrModule.module,
+        action: dataOrModule.action,
+        message: dataOrModule.message,
+        ...dataOrModule.context ? { context: dataOrModule.context } : {}
+      };
+    }
+    return {
+      type: level || "info",
+      module: dataOrModule,
+      action,
+      message
+    };
+  }
+  /**
+   * Make log
+   */
+  async log(data) {
+    for (const channel of this.channels) {
+      if (channel.terminal === false) {
+        data.message = clearMessage(data.message);
+      }
+      channel.log(data);
+    }
+    return this;
+  }
+  /**
+   * Make debug log
+   */
+  debug(dataOrModule, action, message = "") {
+    const data = this.normalizeLogData(dataOrModule, action, message, "debug");
+    return this.log(data);
+  }
+  /**
+   * Make info log
+   */
+  info(dataOrModule, action, message = "") {
+    const data = this.normalizeLogData(dataOrModule, action, message, "info");
+    return this.log(data);
+  }
+  /**
+   * Make warn log
+   */
+  warn(dataOrModule, action, message = "") {
+    const data = this.normalizeLogData(dataOrModule, action, message, "warn");
+    return this.log(data);
+  }
+  /**
+   * Make error log
+   */
+  error(dataOrModule, action, message = "") {
+    const data = this.normalizeLogData(dataOrModule, action, message, "error");
+    return this.log(data);
+  }
+  /**
+   * Make success log
+   */
+  success(dataOrModule, action, message = "") {
+    const data = this.normalizeLogData(
+      dataOrModule,
+      action,
+      message,
+      "success"
+    );
+    return this.log(data);
+  }
+  /**
+   * Get channel by name
+   */
+  channel(name) {
+    return this.channels.find((channel) => channel.name === name);
+  }
+};
+var logger = new Logger();
+var log = (data) => {
+  return logger.log(data);
+};
+log.info = logger.info.bind(logger);
+log.debug = logger.debug.bind(logger);
+log.warn = logger.warn.bind(logger);
+log.error = logger.error.bind(logger);
+log.success = logger.success.bind(logger);
+log.channel = logger.channel.bind(logger);
+
+// ../../warlock.js/logger/src/utils/capture-unhandled-errors.ts
+function captureAnyUnhandledRejection() {
+  process.on("unhandledRejection", (reason, promise) => {
+    log.error("app", "unhandledRejection", reason);
+    console.log(promise);
+  });
+  process.on("uncaughtException", (error) => {
+    log.error("app", "uncaughtException", error);
+    console.log(error);
+  });
+}
+
+export { ConsoleLog, FileLog, JSONFileLog, LogChannel, Logger, captureAnyUnhandledRejection, clearMessage, log, logger };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map