@ncoderz/log-m8 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -144,6 +144,7 @@ var import_fs = require("fs");
 
 // src/LogM8Utils.ts
 var TIMESTAMP_TOKEN_REGEX = /(yyyy|SSS|hh|mm|ss|SS|zz|z|yy|MM|dd|A|a|h|S)/g;
+var REGEX_MATCHER = /^\/(.+)\/([dgimsuvy]*)$/;
 var EXCLUDED_ERROR_KEYS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
 var COMMON_NON_ENUMERABLE_PROPS = ["code", "errno", "syscall", "path"];
 var LogM8Utils = class _LogM8Utils {
@@ -539,6 +540,31 @@ var LogM8Utils = class _LogM8Utils {
     };
     return serializeErrorInternal(error, /* @__PURE__ */ new WeakSet());
   }
+  /**
+   * Take a regex in the format /regex/flags and parse it into a RegExp object
+   *
+   * @param regex regex in the format /regex/flags
+   * @param extraFlags additional flags to apply to the regex
+   * @returns RegExp object or undefined if the regex is invalid
+   */
+  static parseRegexFromString(regex, extraFlags) {
+    try {
+      const match = regex.match(REGEX_MATCHER);
+      if (match == null) return void 0;
+      const [, pattern, flags] = match;
+      let finalFlags = flags;
+      if (Array.isArray(extraFlags)) {
+        for (const flag of extraFlags) {
+          if (!flags.includes(flag)) {
+            finalFlags += flag;
+          }
+        }
+      }
+      return new RegExp(pattern, finalFlags);
+    } catch (_e) {
+      return void 0;
+    }
+  }
 };
 
 // src/appenders/FileAppender.ts
@@ -639,8 +665,8 @@ var MatchFilter = class {
    */
   init(config) {
     const cfg = config ?? {};
-    this._allow = cfg.allow ?? void 0;
-    this._deny = cfg.deny ?? void 0;
+    this._allow = this._prepareRules(cfg.allow);
+    this._deny = this._prepareRules(cfg.deny);
     this.enabled = cfg.enabled !== false;
   }
   dispose() {
@@ -658,13 +684,13 @@ var MatchFilter = class {
       if (this._allow && Object.keys(this._allow).length > 0) {
         for (const [path, expected] of Object.entries(this._allow)) {
           const actual = LogM8Utils.getPropertyByPath(logEvent, path);
-          if (!this._isEqual(actual, expected)) return false;
+          if (!this._matches(actual, expected)) return false;
         }
       }
       if (this._deny && Object.keys(this._deny).length > 0) {
         for (const [path, expected] of Object.entries(this._deny)) {
           const actual = LogM8Utils.getPropertyByPath(logEvent, path);
-          if (this._isEqual(actual, expected)) return false;
+          if (this._matches(actual, expected)) return false;
         }
       }
       return true;
@@ -672,6 +698,15 @@ var MatchFilter = class {
       return false;
     }
   }
+  // Matches actual against expected, supporting RegExp; otherwise deep equality.
+  _matches(actual, expected) {
+    if (expected instanceof RegExp) {
+      if (actual === void 0 || actual === null) return false;
+      const asString = typeof actual === "string" ? actual : String(actual);
+      return expected.test(asString);
+    }
+    return this._isEqual(actual, expected);
+  }
   // Simple deep equality for primitives, arrays, plain objects, dates
   _isEqual(a, b) {
     if (a === b) return true;
@@ -702,6 +737,20 @@ var MatchFilter = class {
   _isPlainObject(val) {
     return typeof val === "object" && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
   }
+  // Convert rule map values: regex-like strings -> RegExp; leave others as-is.
+  _prepareRules(map) {
+    if (!map || Object.keys(map).length === 0) return void 0;
+    const prepared = {};
+    for (const [path, val] of Object.entries(map)) {
+      if (typeof val === "string") {
+        const rx = LogM8Utils.parseRegexFromString(val);
+        prepared[path] = rx ?? val;
+      } else {
+        prepared[path] = val;
+      }
+    }
+    return prepared;
+  }
 };
 var MatchFilterFactory = class {
   constructor() {