@mrxsys/mrx-core 2.11.1-1-and-275-20251023 → 2.12.0-1-and-288-20251203

package/dist/modules/jwt/enums/jwt-error-keys.d.ts

@@ -1,5 +1,5 @@
 export declare const JWT_ERROR_KEYS: {
-    readonly JWT_EXPIRATION_PASSED: "mrx-core.jwt.error.expiration_passed";
-    readonly JWT_SECRET_NOT_FOUND: "mrx-core.jwt.error.secret_not_found";
-    readonly JWT_SIGN_ERROR: "mrx-core.jwt.error.sign_error";
+    readonly JWT_EXPIRATION_PASSED: "mrx.mrx-core.jwt.error.expiration_passed";
+    readonly JWT_SECRET_NOT_FOUND: "mrx.mrx-core.jwt.error.secret_not_found";
+    readonly JWT_SIGN_ERROR: "mrx.mrx-core.jwt.error.sign_error";
 };

package/dist/modules/jwt/enums/parse-human-time-to-seconds-error-keys.d.ts

@@ -1,3 +1,3 @@
 export declare const PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS: {
-    readonly INVALID_TIME_EXPRESSION: "mrx-core.parse_human_time_to_seconds.error.invalid_time_expression";
+    readonly INVALID_TIME_EXPRESSION: "mrx.mrx-core.jwt.parse_human_time_to_seconds.error.invalid_time_expression";
 };

package/dist/modules/jwt/index.js

@@ -1,26 +1,24 @@
 // @bun
 import {
   JWT_ERROR_KEYS
-} from "../../chunk-9d3zvgp6.js";
+} from "../../chunk-zn2nm5gg.js";
 import {
   parseHumanTimeToSeconds
-} from "../../chunk-eeb7yskp.js";
-import"../../chunk-12qzn7jw.js";
+} from "../../chunk-awphtyzp.js";
+import"../../chunk-dmsev7vs.js";
 import {
-  HttpError
-} from "../../chunk-7t524zqh.js";
-import"../../chunk-sqts8vyk.js";
-import"../../chunk-9cgzhc50.js";
+  InternalError
+} from "../../chunk-jz3wd472.js";
 
 // source/modules/jwt/jwt.ts
 import {
   SignJWT,
   jwtVerify
 } from "jose";
-var signJWT = (secret, payload, expiration = Math.floor(Date.now() / 1000) + 60 * 15) => {
-  const exp = expiration instanceof Date ? Math.floor(expiration.getTime() / 1000) : typeof expiration === "number" ? expiration : Math.floor(Date.now() / 1000) + parseHumanTimeToSeconds(expiration);
+var signJWT = (secret, payload, expiration = 60 * 15) => {
+  const exp = expiration instanceof Date ? Math.floor(expiration.getTime() / 1000) : typeof expiration === "number" ? Math.floor(Date.now() / 1000) + expiration : Math.floor(Date.now() / 1000) + parseHumanTimeToSeconds(expiration);
   if (exp <= Math.floor(Date.now() / 1000))
-    throw new HttpError(JWT_ERROR_KEYS.JWT_EXPIRATION_PASSED, "BAD_REQUEST");
+    throw new InternalError(JWT_ERROR_KEYS.JWT_EXPIRATION_PASSED);
   const finalPayload = {
     iss: "Core-Issuer",
     sub: "",
@@ -32,10 +30,10 @@ var signJWT = (secret, payload, expiration = Math.floor(Date.now() / 1000) + 60
     ...payload
   };
   try {
-    const jwt = new SignJWT(finalPayload).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuer(finalPayload.iss).setSubject(finalPayload.sub).setAudience(finalPayload.aud).setJti(finalPayload.jti).setNotBefore(finalPayload.nbf).setIssuedAt(finalPayload.iat).setExpirationTime(expiration).sign(new TextEncoder().encode(secret));
+    const jwt = new SignJWT(finalPayload).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuer(finalPayload.iss).setSubject(finalPayload.sub).setAudience(finalPayload.aud).setJti(finalPayload.jti).setNotBefore(finalPayload.nbf).setIssuedAt(finalPayload.iat).setExpirationTime(exp).sign(new TextEncoder().encode(secret));
     return jwt;
   } catch (error) {
-    throw new HttpError(JWT_ERROR_KEYS.JWT_SIGN_ERROR, "INTERNAL_SERVER_ERROR", error);
+    throw new InternalError(JWT_ERROR_KEYS.JWT_SIGN_ERROR, error);
   }
 };
 var verifyJWT = async (token, secret) => {

package/dist/modules/jwt/utils/index.js

@@ -1,9 +1,9 @@
 // @bun
 import {
   parseHumanTimeToSeconds
-} from "../../../chunk-eeb7yskp.js";
-import"../../../chunk-12qzn7jw.js";
-import"../../../chunk-9cgzhc50.js";
+} from "../../../chunk-awphtyzp.js";
+import"../../../chunk-dmsev7vs.js";
+import"../../../chunk-jz3wd472.js";
 export {
   parseHumanTimeToSeconds
 };

package/dist/modules/jwt/utils/parse-human-time-to-seconds.d.ts

@@ -3,7 +3,7 @@
  *
  * @param timeExpression - A string representing a time period (e.g., "2 hours", "30 minutes ago", "+1 day")
  *
- * @throws ({@link BaseError}) - If the time expression is invalid or contains an unknown unit
+ * @throws ({@link InternalError}) - If the time expression is invalid or contains an unknown unit
  *
  * @returns The time period in seconds (negative for past times)
 *

package/dist/modules/kv-store/bun-redis/index.js

@@ -1,10 +1,10 @@
 // @bun
 import {
   KV_STORE_ERROR_KEYS
-} from "../../../chunk-xhhj1gvj.js";
+} from "../../../chunk-8pw0syzf.js";
 import {
-  BaseError
-} from "../../../chunk-9cgzhc50.js";
+  InternalError
+} from "../../../chunk-jz3wd472.js";
 
 // source/modules/kv-store/bun-redis/bun-redis-store.ts
 var {RedisClient } = globalThis.Bun;
@@ -14,10 +14,18 @@ class BunRedisStore {
     this._client = new RedisClient(url, options);
   }
   async connect() {
-    await this._client.connect();
+    try {
+      await this._client.connect();
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+    }
   }
   close() {
-    this._client.close();
+    try {
+      this._client.close();
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+    }
   }
   async get(key) {
     const value = await this._client.get(key);
@@ -37,20 +45,20 @@ class BunRedisStore {
       await this._client.set(key, serialized);
   }
   async increment(key, amount) {
-    let current = Number(await this._client.get(key));
-    if (current !== null && isNaN(current))
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    current += amount ?? 1;
-    await this._client.set(key, current.toString());
-    return current;
+    try {
+      const number = await this._client.incrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
   }
   async decrement(key, amount) {
-    let current = Number(await this._client.get(key));
-    if (current !== null && isNaN(current))
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    current -= amount ?? 1;
-    await this._client.set(key, current.toString());
-    return current;
+    try {
+      const number = await this._client.decrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
   }
   async del(key) {
     const res = await this._client.del(key);

package/dist/modules/kv-store/enums/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   KV_STORE_ERROR_KEYS
-} from "../../../chunk-xhhj1gvj.js";
+} from "../../../chunk-8pw0syzf.js";
 export {
   KV_STORE_ERROR_KEYS
 };

package/dist/modules/kv-store/enums/kv-store-error-keys.d.ts

@@ -1,5 +1,5 @@
 export declare const KV_STORE_ERROR_KEYS: {
-    readonly CLOSING_CONNECTION_FAILED: "mrx-core.kv-store.error.closing_connection_failed";
-    readonly CONNECTION_FAILED: "mrx-core.kv-store.error.connection_failed";
-    readonly NOT_INTEGER: "mrx-core.kv-store.error.not_integer";
+    readonly CLOSING_CONNECTION_FAILED: "mrx.mrx-core.kv-store.error.closing_connection_failed";
+    readonly CONNECTION_FAILED: "mrx.mrx-core.kv-store.error.connection_failed";
+    readonly NOT_INTEGER: "mrx.mrx-core.kv-store.error.not_integer";
 };

package/dist/modules/kv-store/ioredis/index.js

@@ -1,10 +1,10 @@
 // @bun
 import {
   KV_STORE_ERROR_KEYS
-} from "../../../chunk-xhhj1gvj.js";
+} from "../../../chunk-8pw0syzf.js";
 import {
-  BaseError
-} from "../../../chunk-9cgzhc50.js";
+  InternalError
+} from "../../../chunk-jz3wd472.js";
 
 // source/modules/kv-store/ioredis/ioredis-store.ts
 import { Redis } from "ioredis";
@@ -20,14 +20,14 @@ class IoRedisStore {
     try {
       await this._client.connect();
     } catch (e) {
-      throw new BaseError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+      throw new InternalError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
     }
   }
   async close() {
     try {
       await this._client.quit();
     } catch (e) {
-      throw new BaseError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+      throw new InternalError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
     }
   }
   async get(key) {
@@ -48,20 +48,20 @@ class IoRedisStore {
       await this._client.set(key, serialized);
   }
   async increment(key, amount = 1) {
-    const current = await this._client.get(key);
-    if (current !== null && isNaN(Number(current)))
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    if (amount === 1)
-      return this._client.incr(key);
-    return this._client.incrby(key, amount);
+    try {
+      const number = await this._client.incrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
   }
   async decrement(key, amount = 1) {
-    const current = await this._client.get(key);
-    if (current !== null && isNaN(Number(current)))
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    if (amount === 1)
-      return this._client.decr(key);
-    return this._client.decrby(key, amount);
+    try {
+      const number = await this._client.decrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new InternalError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
   }
   async del(key) {
     const result = await this._client.del(key);

package/dist/modules/kv-store/memory/index.js

@@ -1,103 +1,9 @@
 // @bun
 import {
-  KV_STORE_ERROR_KEYS
-} from "../../../chunk-xhhj1gvj.js";
-import {
-  BaseError
-} from "../../../chunk-9cgzhc50.js";
-
-// source/modules/kv-store/memory/memory-store.ts
-class MemoryStore {
-  _store = new Map;
-  _cleanupInterval;
-  _cleanupTimer = null;
-  constructor(cleanupIntervalMs) {
-    this._cleanupInterval = cleanupIntervalMs ?? 300000;
-    this._startCleanup();
-  }
-  get(key) {
-    const entry = this._store.get(key);
-    if (!entry)
-      return null;
-    const now = Date.now();
-    if (now > entry.expiresAt && entry.expiresAt !== -1) {
-      this._store.delete(key);
-      return null;
-    }
-    return entry.value;
-  }
-  set(key, value, ttlSec) {
-    const expiresAt = ttlSec ? Date.now() + ttlSec * 1000 : -1;
-    this._store.set(key, { value, expiresAt });
-  }
-  increment(key, amount = 1) {
-    const current = this.get(key);
-    const entry = this._store.get(key);
-    if (current !== null && typeof current !== "number")
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    const currentValue = current ?? 0;
-    const newValue = currentValue + amount;
-    const expiresAt = entry ? entry.expiresAt : -1;
-    this._store.set(key, { value: newValue, expiresAt });
-    return newValue;
-  }
-  decrement(key, amount = 1) {
-    const current = this.get(key);
-    const entry = this._store.get(key);
-    if (current !== null && typeof current !== "number")
-      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
-    const currentValue = current ?? 0;
-    const newValue = currentValue - amount;
-    const expiresAt = entry ? entry.expiresAt : -1;
-    this._store.set(key, { value: newValue, expiresAt });
-    return newValue;
-  }
-  del(key) {
-    return this._store.delete(key);
-  }
-  expire(key, ttlSec) {
-    const entry = this._store.get(key);
-    if (!entry)
-      return false;
-    entry.expiresAt = Date.now() + ttlSec * 1000;
-    return true;
-  }
-  ttl(key) {
-    const entry = this._store.get(key);
-    if (!entry)
-      return -1;
-    if (entry.expiresAt === -1)
-      return -1;
-    const remaining = entry.expiresAt - Date.now();
-    return remaining > 0 ? Math.ceil(remaining / 1000) : -1;
-  }
-  clean() {
-    const sizeBefore = this._store.size;
-    this._store.clear();
-    return sizeBefore;
-  }
-  _startCleanup() {
-    if (this._cleanupTimer)
-      return;
-    this._cleanupTimer = setInterval(() => {
-      this._removeExpiredEntries();
-    }, this._cleanupInterval);
-  }
-  _removeExpiredEntries() {
-    const now = Date.now();
-    for (const [key, entry] of this._store.entries())
-      if (entry.expiresAt !== -1 && now > entry.expiresAt)
-        this._store.delete(key);
-  }
-  destroy() {
-    if (this._cleanupTimer) {
-      clearInterval(this._cleanupTimer);
-      this._cleanupTimer = null;
-    }
-    this._store.clear();
-  }
-}
+  MemoryStore
+} from "../../../chunk-j7dyc5ks.js";
+import"../../../chunk-8pw0syzf.js";
+import"../../../chunk-jz3wd472.js";
 export {
   MemoryStore
 };
-export { MemoryStore };

package/dist/modules/logger/enums/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   LOGGER_ERROR_KEYS
-} from "../../../chunk-rz5p4j3p.js";
+} from "../../../chunk-6hs00zfd.js";
 export {
   LOGGER_ERROR_KEYS
 };

package/dist/modules/logger/enums/logger-error-keys.d.ts

@@ -1,9 +1,9 @@
 export declare const LOGGER_ERROR_KEYS: {
-    readonly BEFORE_EXIT_CLOSE_ERROR: "mrx-core.logger.error.before_exit_close_error";
-    readonly BEFORE_EXIT_FLUSH_ERROR: "mrx-core.logger.error.before_exit_flush_error";
-    readonly NO_SINKS_PROVIDED: "mrx-core.logger.error.no_sinks_provided";
-    readonly REGISTER_SINK_ERROR: "mrx-core.logger.error.register_sink_error";
-    readonly SINK_ALREADY_ADDED: "mrx-core.logger.error.sink_already_added";
-    readonly SINK_CLOSE_ERROR: "mrx-core.logger.error.sink_close_error";
-    readonly SINK_LOG_ERROR: "mrx-core.logger.error.sink_log_error";
+    readonly BEFORE_EXIT_CLOSE_ERROR: "mrx.mrx-core.logger.error.before_exit_close_error";
+    readonly BEFORE_EXIT_FLUSH_ERROR: "mrx.mrx-core.logger.error.before_exit_flush_error";
+    readonly NO_SINKS_PROVIDED: "mrx.mrx-core.logger.error.no_sinks_provided";
+    readonly REGISTER_SINK_ERROR: "mrx.mrx-core.logger.error.register_sink_error";
+    readonly SINK_ALREADY_ADDED: "mrx.mrx-core.logger.error.sink_already_added";
+    readonly SINK_CLOSE_ERROR: "mrx.mrx-core.logger.error.sink_close_error";
+    readonly SINK_LOG_ERROR: "mrx.mrx-core.logger.error.sink_log_error";
 };

package/dist/modules/logger/events/logger-events.d.ts

@@ -1,16 +1,16 @@
-import type { BaseError } from '../../../errors/base-error';
+import type { InternalError } from '../../../errors/internal-error';
 export interface LoggerEvent {
-    onBeforeExitError: [BaseError<{
+    onBeforeExitError: [InternalError<{
         error: Error;
     }>];
     registerSinkError: [
-        BaseError<{
+        InternalError<{
             sinkName: string;
             error: Error;
         }>
     ];
     sinkError: [
-        BaseError<{
+        InternalError<{
             sinkName: string;
             object?: unknown;
             error: Error;

package/dist/modules/logger/index.js

@@ -1,13 +1,88 @@
 // @bun
+import"../typed-event-emitter/index.js";
 import {
   LOGGER_ERROR_KEYS
-} from "../../chunk-rz5p4j3p.js";
+} from "../../chunk-6hs00zfd.js";
 import {
   TypedEventEmitter
 } from "../../chunk-mvrxngm7.js";
 import {
-  BaseError
-} from "../../chunk-9cgzhc50.js";
+  InternalError
+} from "../../chunk-jz3wd472.js";
+
+// source/modules/logger/worker-logger.ts
+var workerFunction = () => {
+  const sinks = {};
+  const self = globalThis;
+  const processLogEntry = async (log) => {
+    await Promise.all(log.sinkNames.map(async (sinkName) => {
+      const sink = sinks[sinkName];
+      if (!sink)
+        return;
+      try {
+        await sink.log(log.level, log.timestamp, log.object);
+      } catch (error) {
+        self.postMessage({
+          type: "SINK_LOG_ERROR",
+          sinkName,
+          error,
+          object: log.object
+        });
+      }
+    }));
+  };
+  self.addEventListener("message", async (event) => {
+    switch (event.data.type) {
+      case "REGISTER_SINK": {
+        const {
+          sinkName,
+          sinkClassName,
+          sinkClassString,
+          sinkArgs
+        } = event.data;
+        try {
+          const factory = new Function("sinkArgs", `
+						${sinkClassString}
+						return new ${sinkClassName}(...sinkArgs);
+					`);
+          sinks[sinkName] = factory(sinkArgs);
+        } catch (error) {
+          self.postMessage({
+            type: "REGISTER_SINK_ERROR",
+            sinkName,
+            error
+          });
+        }
+        break;
+      }
+      case "LOG_BATCH": {
+        const { logs } = event.data;
+        try {
+          for (const log of logs)
+            await processLogEntry(log);
+        } finally {
+          self.postMessage({ type: "BATCH_COMPLETE" });
+        }
+        break;
+      }
+      case "CLOSE": {
+        await Promise.all(Object.entries(sinks).map(async ([name, sink]) => {
+          try {
+            await sink.close?.();
+          } catch (error) {
+            self.postMessage({
+              type: "SINK_CLOSE_ERROR",
+              sinkName: name,
+              error
+            });
+          }
+        }));
+        self.postMessage({ type: "CLOSE_COMPLETE" });
+        break;
+      }
+    }
+  });
+};
 
 // source/modules/logger/logger.ts
 class Logger extends TypedEventEmitter {
@@ -51,14 +126,14 @@ class Logger extends TypedEventEmitter {
     this._batchTimeout = batchTimeout;
     this._autoEnd = autoEnd;
     this._flushOnBeforeExit = flushOnBeforeExit;
-    this._worker = new Worker(new URL("worker-logger.ts", import.meta.url).href, { type: "module" });
+    this._worker = new Worker(URL.createObjectURL(new Blob([`(${workerFunction.toString()})()`], { type: "application/javascript" })), { type: "module" });
     this._setupWorkerMessages();
     if (this._autoEnd)
       this._setupAutoEnd();
   }
   registerSink(sinkName, sinkConstructor, ...sinkArgs) {
     if (this._sinks[sinkName])
-      throw new Error(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED);
+      throw new InternalError(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED);
     this._worker.postMessage({
       type: "REGISTER_SINK",
       sinkName,
@@ -70,19 +145,19 @@ class Logger extends TypedEventEmitter {
     this._sinkKeys.push(sinkName);
     return this;
   }
-  error(object, sinkNames) {
+  error(object, sinkNames = this._sinkKeys) {
     this._enqueue("ERROR", object, sinkNames);
   }
-  warn(object, sinkNames) {
+  warn(object, sinkNames = this._sinkKeys) {
     this._enqueue("WARN", object, sinkNames);
   }
-  info(object, sinkNames) {
+  info(object, sinkNames = this._sinkKeys) {
     this._enqueue("INFO", object, sinkNames);
   }
-  debug(object, sinkNames) {
+  debug(object, sinkNames = this._sinkKeys) {
     this._enqueue("DEBUG", object, sinkNames);
   }
-  log(object, sinkNames = Object.keys(this._sinks)) {
+  log(object, sinkNames = this._sinkKeys) {
     this._enqueue("LOG", object, sinkNames);
   }
   async flush() {
@@ -105,7 +180,7 @@ class Logger extends TypedEventEmitter {
   }
   _enqueue(level, object, sinkNames) {
     if (this._sinkKeys.length === 0)
-      throw new BaseError(LOGGER_ERROR_KEYS.NO_SINKS_PROVIDED, { level, object });
+      throw new InternalError(LOGGER_ERROR_KEYS.NO_SINKS_PROVIDED, { level, object });
     if (this._pendingLogs.length >= this._maxPendingLogs)
       return;
     this._pendingLogs.push({
@@ -168,14 +243,14 @@ class Logger extends TypedEventEmitter {
           }
           break;
         case "SINK_LOG_ERROR":
-          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_LOG_ERROR, event.data));
+          this.emit("sinkError", new InternalError(LOGGER_ERROR_KEYS.SINK_LOG_ERROR, event.data));
           this._releaseBatch();
           break;
         case "SINK_CLOSE_ERROR":
-          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_CLOSE_ERROR, event.data));
+          this.emit("sinkError", new InternalError(LOGGER_ERROR_KEYS.SINK_CLOSE_ERROR, event.data));
           break;
         case "REGISTER_SINK_ERROR":
-          this.emit("registerSinkError", new BaseError(LOGGER_ERROR_KEYS.REGISTER_SINK_ERROR, event.data));
+          this.emit("registerSinkError", new InternalError(LOGGER_ERROR_KEYS.REGISTER_SINK_ERROR, event.data));
           break;
         case "CLOSE_COMPLETE":
           this._worker.terminate();
@@ -195,15 +270,11 @@ class Logger extends TypedEventEmitter {
   _handleBeforeExit = () => {
     if (this._flushOnBeforeExit)
       this.flush().then(() => this.close()).catch((error) => {
-        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_FLUSH_ERROR, {
-          error: error instanceof Error ? error : new Error("Unknown error during logger flush on beforeExit")
-        }));
+        this.emit("onBeforeExitError", new InternalError(LOGGER_ERROR_KEYS.BEFORE_EXIT_FLUSH_ERROR, { error }));
       });
     else
       this.close().catch((error) => {
-        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_CLOSE_ERROR, {
-          error: error instanceof Error ? error : new Error("Unknown error during logger close on beforeExit")
-        }));
+        this.emit("onBeforeExitError", new InternalError(LOGGER_ERROR_KEYS.BEFORE_EXIT_CLOSE_ERROR, { error }));
       });
   };
 }

package/dist/modules/logger/logger.d.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter } from '../../modules/typed-event-emitter/typed-event-emitter';
+import { TypedEventEmitter } from '../../modules/typed-event-emitter';
 import type { LoggerEvent } from './events/logger-events';
 import type { LoggerOptions } from './types/logger-options';
 import type { LoggerSink } from './types/logger-sink';
@@ -104,7 +104,7 @@ export declare class Logger<TSinks extends SinkMap = {}> extends TypedEventEmitt
      * Logs a message at the WARN level to the specified sinks.
      *
      * @param object - The log message object
-     * @param sinkNames - Optionnal array of sink names to log to; logs to all sinks if omitted
+     * @param sinkNames - Optional array of sink names to log to; logs to all sinks if omitted
      */
     warn<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: SinkBodiesIntersection<TSinks, SNames[number]>, sinkNames?: SNames): void;
     /**

package/dist/modules/logger/sinks/console-logger.d.ts

@@ -4,5 +4,5 @@ import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
 * ConsoleLoggerSink implements LoggerSink to provide logging functionality to the console.
 */
 export declare class ConsoleLoggerSink<TLogObject = unknown> implements LoggerSink<TLogObject> {
-    log(level: LogLevels, timestamp: number, object: TLogObject): Promise<void>;
+    log(level: LogLevels, timestamp: number, object: TLogObject): void;
 }

package/dist/modules/logger/sinks/file-logger/enums/file-logger-error-keys.d.ts

@@ -1,3 +1,3 @@
 export declare const FILE_LOGGER_ERROR_KEYS: {
-    readonly FAILED_TO_CLOSE_STREAM: "mrx-core.file_logger.error.failed_to_close_stream";
+    readonly FAILED_TO_CLOSE_STREAM: "nowarajs.logger.file_logger.error.failed_to_close_stream";
 };

package/dist/modules/logger/sinks/file-logger/file-logger.d.ts

@@ -12,9 +12,9 @@ export interface FileLoggerConfig {
     bufferSize?: number;
 }
 /**
-* FileLoggerSink implements LoggerSink to provide logging functionality to the file system.
-* Uses a WriteStream for efficient buffered writes (like Pino's sonic-boom).
-*/
+ * FileLoggerSink implements LoggerSink to provide logging functionality to the file system.
+ * Uses a WriteStream for efficient buffered writes (like Pino's sonic-boom).
+ */
 export declare class FileLoggerSink<TLogObject = unknown> implements LoggerSink<TLogObject> {
     readonly config: FileLoggerConfig;
     private readonly _stream;