plslog 1.1.1 → 1.2.0

package/dist/index.mjs

@@ -20,7 +20,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 
@@ -1042,7 +1042,7 @@ var require_build = __commonJS({
           value: true
         });
         exports2["default"] = exports2.DEFAULT_OPTIONS = void 0;
-        exports2.format = format2;
+        exports2.format = format;
         exports2.plugins = void 0;
         var _ansiStyles = _interopRequireDefault(require_ansi_styles());
         var _collections = __webpack_require__("./src/collections.ts");
@@ -1205,8 +1205,8 @@ ${indentationNext}`);
           }
           return printed;
         }
-        function findPlugin(plugins3, val) {
-          for (const plugin of plugins3) {
+        function findPlugin(plugins2, val) {
+          for (const plugin of plugins2) {
             try {
               if (plugin.test(val)) {
                 return plugin;
@@ -1237,7 +1237,7 @@ ${indentationNext}`);
         };
         const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
         const toOptionsSubtype = (options) => options;
-        const DEFAULT_OPTIONS2 = exports2.DEFAULT_OPTIONS = toOptionsSubtype({
+        const DEFAULT_OPTIONS = exports2.DEFAULT_OPTIONS = toOptionsSubtype({
           callToJSON: true,
           compareKeys: void 0,
           escapeRegex: false,
@@ -1254,7 +1254,7 @@ ${indentationNext}`);
         });
         function validateOptions(options) {
           for (const key of Object.keys(options)) {
-            if (!Object.prototype.hasOwnProperty.call(DEFAULT_OPTIONS2, key)) {
+            if (!Object.prototype.hasOwnProperty.call(DEFAULT_OPTIONS, key)) {
               throw new Error(`pretty-format: Unknown option "${key}".`);
             }
           }
@@ -1287,20 +1287,20 @@ ${indentationNext}`);
           };
           return colors;
         }, /* @__PURE__ */ Object.create(null));
-        const getPrintFunctionName = (options) => options?.printFunctionName ?? DEFAULT_OPTIONS2.printFunctionName;
-        const getEscapeRegex = (options) => options?.escapeRegex ?? DEFAULT_OPTIONS2.escapeRegex;
-        const getEscapeString = (options) => options?.escapeString ?? DEFAULT_OPTIONS2.escapeString;
+        const getPrintFunctionName = (options) => options?.printFunctionName ?? DEFAULT_OPTIONS.printFunctionName;
+        const getEscapeRegex = (options) => options?.escapeRegex ?? DEFAULT_OPTIONS.escapeRegex;
+        const getEscapeString = (options) => options?.escapeString ?? DEFAULT_OPTIONS.escapeString;
         const getConfig = (options) => ({
-          callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS2.callToJSON,
+          callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS.callToJSON,
           colors: options?.highlight ? getColorsHighlight(options) : getColorsEmpty(),
-          compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS2.compareKeys,
+          compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
           escapeRegex: getEscapeRegex(options),
           escapeString: getEscapeString(options),
-          indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS2.indent),
-          maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS2.maxDepth,
-          maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS2.maxWidth,
-          min: options?.min ?? DEFAULT_OPTIONS2.min,
-          plugins: options?.plugins ?? DEFAULT_OPTIONS2.plugins,
+          indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS.indent),
+          maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS.maxDepth,
+          maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS.maxWidth,
+          min: options?.min ?? DEFAULT_OPTIONS.min,
+          plugins: options?.plugins ?? DEFAULT_OPTIONS.plugins,
           printBasicPrototype: options?.printBasicPrototype ?? true,
           printFunctionName: getPrintFunctionName(options),
           spacingInner: options?.min ? " " : "\n",
@@ -1311,7 +1311,7 @@ ${indentationNext}`);
             length: indent + 1
           }).join(" ");
         }
-        function format2(val, options) {
+        function format(val, options) {
           if (options) {
             validateOptions(options);
             if (options.plugins) {
@@ -1335,7 +1335,7 @@ ${indentationNext}`);
           ReactElement: _ReactElement.default,
           ReactTestComponent: _ReactTestComponent.default
         };
-        exports2["default"] = format2;
+        exports2["default"] = format;
       })();
       module.exports = __webpack_exports__;
     })();
@@ -1349,14 +1349,9 @@ function isBase64(link) {
   return link.startsWith("data:image/") && link.includes(";base64");
 }
 
-// ../../node_modules/.pnpm/pretty-format@30.2.0/node_modules/pretty-format/build/index.mjs
-var import_index = __toESM(require_build());
-import_index.default.DEFAULT_OPTIONS;
-var format = import_index.default.format;
-import_index.default.plugins;
-import_index.default.default;
-
 // src/formatter.ts
+var import_pretty_format = __toESM(require_build());
+var prettyFormat = typeof import_pretty_format.default === "function" ? import_pretty_format.default : import_pretty_format.default.format;
 var EXCLUDED_ERROR_PROPS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
 var Formatter = class {
   /**
@@ -1567,8 +1562,15 @@ var Formatter = class {
     if (obj instanceof Error) {
       return this.serializeError(obj, filterOptions?.errorConfig, 0);
     }
-    if (typeof obj === "string" && isBase64(obj)) {
-      return this.formatBase64String(obj);
+    if (typeof obj === "string") {
+      if (isBase64(obj)) {
+        return this.formatBase64String(obj);
+      }
+      const stringLimit = filterOptions?.truncate?.string;
+      if (stringLimit !== void 0 && obj.length > stringLimit) {
+        return `${obj.slice(0, stringLimit)}... [${obj.length} chars]`;
+      }
+      return obj;
     }
     if (obj instanceof File) {
       return {
@@ -1585,7 +1587,10 @@ var Formatter = class {
       };
     }
     if (Array.isArray(obj)) {
-      return obj.map(
+      const arrayLimit = filterOptions?.truncate?.array;
+      const sourceItems = arrayLimit !== void 0 && obj.length > arrayLimit ? obj.slice(0, arrayLimit) : obj;
+      const remainder = obj.length - sourceItems.length;
+      const result = sourceItems.map(
         (item, index) => this.serializeSpecialObjects(
           item,
           maxDepth,
@@ -1594,55 +1599,64 @@ var Formatter = class {
           [...currentPath, `[${index}]`]
         )
       );
+      if (remainder > 0) {
+        result.push(`... +${remainder} more`);
+      }
+      return result;
     }
     if (obj !== null && typeof obj === "object") {
       const serialized = {};
+      const fieldLimit = filterOptions?.truncate?.fields;
+      const includableEntries = [];
       for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
           const value = obj[key];
-          const newPath = [...currentPath, key];
-          const { include, filtered } = this.shouldIncludeField(
-            key,
+          const { include, filtered } = this.shouldIncludeField(key, value, currentPath, filterOptions);
+          if (include) {
+            includableEntries.push({ key, value, filtered });
+          }
+        }
+      }
+      const visibleCount = fieldLimit !== void 0 ? Math.min(fieldLimit, includableEntries.length) : includableEntries.length;
+      const remainder = includableEntries.length - visibleCount;
+      for (let i = 0; i < visibleCount; i++) {
+        const { key, value, filtered } = includableEntries[i];
+        const newPath = [...currentPath, key];
+        let isGloballyFiltered = false;
+        if (filterOptions?.filterFields && filterOptions.filterFields.length > 0) {
+          isGloballyFiltered = this.shouldFilterField(key, value, currentPath, filterOptions.filterFields);
+        }
+        if (isGloballyFiltered) {
+          const filteredValue = this.getFilteredValue(
             value,
-            currentPath,
-            filterOptions
+            filterOptions?.globalFilterMode,
+            filterOptions?.globalFilterReplacement
           );
-          if (!include) {
-            continue;
+          if (filteredValue !== void 0) {
+            serialized[key] = filteredValue;
           }
-          let isGloballyFiltered = false;
-          if (filterOptions?.filterFields && filterOptions.filterFields.length > 0) {
-            isGloballyFiltered = this.shouldFilterField(key, value, currentPath, filterOptions.filterFields);
-          }
-          if (isGloballyFiltered) {
-            const filteredValue = this.getFilteredValue(
-              value,
-              filterOptions?.globalFilterMode,
-              filterOptions?.globalFilterReplacement
-            );
-            if (filteredValue !== void 0) {
-              serialized[key] = filteredValue;
-            }
-          } else if (filtered) {
-            const filteredValue = this.getFilteredValue(
-              value,
-              filterOptions?.filterMode,
-              filterOptions?.filterReplacement
-            );
-            if (filteredValue !== void 0) {
-              serialized[key] = filteredValue;
-            }
-          } else {
-            serialized[key] = this.serializeSpecialObjects(
-              value,
-              maxDepth,
-              currentDepth + 1,
-              filterOptions,
-              newPath
-            );
+        } else if (filtered) {
+          const filteredValue = this.getFilteredValue(
+            value,
+            filterOptions?.filterMode,
+            filterOptions?.filterReplacement
+          );
+          if (filteredValue !== void 0) {
+            serialized[key] = filteredValue;
           }
+        } else {
+          serialized[key] = this.serializeSpecialObjects(
+            value,
+            maxDepth,
+            currentDepth + 1,
+            filterOptions,
+            newPath
+          );
         }
       }
+      if (remainder > 0) {
+        serialized["..."] = `+${remainder} more fields`;
+      }
       return serialized;
     }
     return obj;
@@ -1671,15 +1685,16 @@ var Formatter = class {
             filterReplacement: options?.filterReplacement,
             globalFilterMode: options?.globalFilterMode,
             globalFilterReplacement: options?.globalFilterReplacement,
-            errorConfig: options?.errorConfig
+            errorConfig: options?.errorConfig,
+            truncate: options?.truncate
           }
         );
-        const formatted = format(serialized, {
+        const formatted = prettyFormat(serialized, {
           indent: 2,
           maxDepth,
-          // Remove Object and Array labels
           printFunctionName: false,
-          printBasicPrototype: false
+          printBasicPrototype: false,
+          compareKeys: null
         });
         const cleaned = formatted.replace(/^Object\s*/, "").replace(/^Array\s*/, "").replace(/\nObject\s*/g, "\n").replace(/\nArray\s*/g, "\n");
         return "\n" + cleaned;
@@ -1897,6 +1912,7 @@ var Logger = class {
     this._namespace = options.namespace ?? DEFAULT_NAMESPACE;
     this._level = options.level ?? globalConfig.level ?? "debug";
     this._maxDepth = options.maxDepth ?? globalConfig.maxDepth ?? 10;
+    this._truncateConfig = options.truncate;
     this._context = options.context ?? {};
     this._dedupConfig = {
       ...DEFAULT_DEDUP_CONFIG,
@@ -1970,6 +1986,24 @@ var Logger = class {
     this._maxDepth = maxDepth;
     return this;
   }
+  /**
+   * Truncate large objects/arrays/strings before logging.
+   * Accepts a number (shorthand for fields limit) or a config object.
+   *
+   * @param config - Max field count (number) or { fields, string, array } limits
+   * @returns this for chaining
+   *
+   * @example
+   * // Limit to 5 fields per object
+   * logger.truncate(5).debug('User', user);
+   *
+   * // Fine-grained control
+   * logger.truncate({ fields: 5, string: 80, array: 3 }).debug('Order', order);
+   */
+  truncate(config) {
+    this._tempFilterOptions.truncate = typeof config === "number" ? { fields: config } : config;
+    return this;
+  }
   /**
    * Pick only specific fields to log (whitelist approach)
    * Supports dot notation for nested fields: 'user.name', 'user.email'
@@ -2082,13 +2116,14 @@ var Logger = class {
     }
     const filterOptions = this._tempFilterOptions;
     this._tempFilterOptions = {};
+    const timestamp = Date.now();
     if (this._dedupConfig.enabled) {
-      this.logWithDedup(level, message, filterOptions, ...args);
+      this.logWithDedup(level, message, filterOptions, timestamp, ...args);
     } else {
-      this.logImmediate(level, message, filterOptions, ...args);
+      this.logImmediate(level, message, filterOptions, timestamp, ...args);
     }
   }
-  logWithDedup(level, message, filterOptions, ...args) {
+  logWithDedup(level, message, filterOptions, timestamp, ...args) {
     const key = dedup_hasher_default.generateKey(level, message, args);
     const existing = this._dedupBuffer.get(key);
     const now = Date.now();
@@ -2110,7 +2145,7 @@ var Logger = class {
         message,
         args,
         count: 1,
-        firstTimestamp: now,
+        firstTimestamp: timestamp,
         lastTimestamp: now,
         filterOptions
       };
@@ -2129,7 +2164,7 @@ var Logger = class {
       const lastTime = this.formatTimestamp(entry.lastTimestamp);
       displayMessage = `${entry.message} (x${entry.count}, ${firstTime} \u2192 ${lastTime})`;
     }
-    this.logImmediate(entry.level, displayMessage, entry.filterOptions || {}, ...entry.args);
+    this.logImmediate(entry.level, displayMessage, entry.filterOptions || {}, entry.firstTimestamp, ...entry.args);
     this._dedupBuffer.delete(key);
   }
   formatTimestamp(timestamp) {
@@ -2140,7 +2175,19 @@ var Logger = class {
     const milliseconds = String(date.getMilliseconds()).padStart(3, "0");
     return `${hours}:${minutes}:${seconds}.${milliseconds}`;
   }
-  logImmediate(level, message, filterOptions, ...args) {
+  logImmediate(level, message, filterOptions, timestamp, ...args) {
+    const transports = globalConfig.transports;
+    if (transports && transports.length > 0) {
+      const entry = { namespace: this._namespace, level, message, args, timestamp };
+      for (const transport of transports) {
+        if (!transport.levels || transport.levels.includes(level)) {
+          try {
+            transport.write(entry);
+          } catch {
+          }
+        }
+      }
+    }
     const formattedObject = Formatter.formatObj(args, {
       maxDepth: this._maxDepth,
       // Global filter fields (always applied for security)
@@ -2153,7 +2200,9 @@ var Logger = class {
       filterMode: filterOptions.filterMode,
       filterReplacement: filterOptions.filterReplacement,
       // Error serialization config
-      errorConfig: globalConfig.errorSerialization
+      errorConfig: globalConfig.errorSerialization,
+      // Truncation: per-log > instance > global
+      truncate: filterOptions.truncate ?? this._truncateConfig ?? globalConfig.truncate
     });
     const formattedMessage = formattedObject ? `${message} ${formattedObject}` : message;
     const { logMessage, logStyles } = styler_default.style({