@naturalcycles/js-lib 15.89.0 → 15.91.0

package/dist/asyncManager.js

@@ -1,5 +1,6 @@
+import { consoleLogger } from './log/commonLogger.js';
 class AsyncManagerImpl {
-    logger = console;
+    logger = consoleLogger;
     pendingOps = new Set();
     onErrorHooks = [];
     runInBackground(promise) {
@@ -48,7 +49,7 @@ class AsyncManagerImpl {
             this.onErrorHooks.forEach(hook => hook(err));
         }
         else {
-            this.logger.error('AsyncManager unhandled rejection:', err);
+            this.logger.error({ msg: 'AsyncManager unhandled rejection', err });
         }
     }
 }

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -13,7 +13,7 @@ export interface AsyncMemoOptions<FN> {
      */
     cacheKeyFn?: (args: MaybeParameters<FN>) => any;
     /**
-     * Default to `console`
+     * Default to `consoleLogger`
      */
     logger?: CommonLogger;
 }

package/dist/decorators/asyncMemo.decorator.js

@@ -1,4 +1,5 @@
 import { _assert, _assertTypeOf } from '../error/assert.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { _objectAssign, MISS } from '../types.js';
 import { _getTargetMethodSignature } from './decorator.util.js';
 import { jsonMemoSerializer } from './memo.util.js';
@@ -20,7 +21,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
     // It only holds values that are "in-flight", until Promise is resolved
     // After it's resolved - it's evicted from the cache and moved to the "proper" `instanceCache`
     const instancePromiseCache = new Map();
-    const { logger = console, cacheFactory, cacheKeyFn = jsonMemoSerializer } = opt;
+    const { logger = consoleLogger, cacheFactory, cacheKeyFn = jsonMemoSerializer } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     // oxlint-disable-next-line @typescript-eslint/promise-function-async
@@ -56,7 +57,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
             return await onMiss();
         }, async (err) => {
             // Log the cache error and proceed "as cache Miss"
-            logger.error(err);
+            logger.error({ err });
             return await onMiss();
         });
         promiseCache.set(cacheKey, promise);
@@ -73,7 +74,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
                         await cache.set(cacheKey, value);
                     }
                     catch (err) {
-                        logger.error(err); // log and ignore the error
+                        logger.error({ err }); // log and ignore the error
                     }
                     finally {
                         // Clear the "in-flight" promise cache entry, as we now have a "permanent" cache entry

package/dist/decorators/logMethod.decorator.d.ts

@@ -40,7 +40,7 @@ export interface LogMethodOptions {
      */
     logResultFn?: LogResultFn;
     /**
-     * Defaults to `console`
+     * Defaults to `consoleLogger`
      */
     logger?: CommonLogger;
 }

package/dist/decorators/logMethod.decorator.js

@@ -1,5 +1,6 @@
 import { _ms } from '../datetime/time.util.js';
 import { _assert } from '../error/assert.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { SimpleMovingAverage } from '../math/sma.js';
 import { _stringify } from '../string/stringify.js';
 import { _getArgsSignature, _getMethodSignature } from './decorator.util.js';
@@ -21,7 +22,7 @@ export function _LogMethod(opt = {}) {
         _assert(typeof descriptor.value === 'function', '@_LogMethod can be applied only to methods');
         const originalFn = descriptor.value;
         const keyStr = String(key);
-        const { avg, logArgs = true, logStart, logResult, logResultLength = true, logger = console, } = opt;
+        const { avg, logArgs = true, logStart, logResult, logResultLength = true, logger = consoleLogger, } = opt;
         let { logResultFn } = opt;
         if (!logResultFn) {
             if (logResult) {
@@ -77,10 +78,14 @@ function logFinished(logger, callSignature, started, sma, logResultFn, res, err)
         t.push(`(avg ${_ms(sma.pushGetAvg(millis))})`);
     }
     if (err !== undefined) {
-        t.push('ERROR:', err);
+        t.push('ERROR:');
     }
     else if (logResultFn) {
         t.push(...logResultFn(res));
     }
-    logger.log(...t.filter(Boolean));
+    const msg = t
+        .filter(Boolean)
+        .map(part => _stringify(part))
+        .join(' ');
+    logger.log(err === undefined ? msg : { msg, err });
 }

package/dist/decorators/memo.decorator.d.ts

@@ -14,7 +14,7 @@ export interface MemoOptions<FN> {
      */
     cacheKeyFn?: (args: MaybeParameters<FN>) => any;
     /**
-     * Default to `console`
+     * Default to `consoleLogger`
      */
     logger?: CommonLogger;
 }

package/dist/decorators/memo.decorator.js

@@ -1,4 +1,5 @@
 import { _assert, _assertTypeOf } from '../error/assert.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { _objectAssign } from '../types.js';
 import { _getTargetMethodSignature } from './decorator.util.js';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
@@ -33,7 +34,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
     // Normal Map is needed to allow .clear()
     const instanceCache = new Map();
-    const { logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logger = consoleLogger, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
@@ -54,7 +55,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
             cache.set(cacheKey, value);
         }
         catch (err) {
-            logger.error(err);
+            logger.error({ err });
         }
         return value;
     };

package/dist/decorators/memoSimple.decorator.js

@@ -3,6 +3,13 @@
 // http://decodize.com/blog/2012/08/27/javascript-memoization-caching-results-for-better-performance/
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
+/*
+Optimized for 0 arguments (using SingleValueCache).
+Optimized for 1 primitive argument (skips JSON.stringify).
+Otherwise resorts to JSON.stringify.
+Benchmark shows similar perf for ObjectCache and MapCache.
+ */
+import { consoleLogger } from '../log/commonLogger.js';
 import { _getTargetMethodSignature } from './decorator.util.js';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 // memoSimple decorator is NOT exported. Only used in benchmarks currently
@@ -34,7 +41,7 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
   }
    */
     const cache = new MapMemoCache();
-    const { logger = console } = opt;
+    const { logger = consoleLogger } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {

package/dist/decorators/memoized.js

@@ -1,3 +1,4 @@
+import { consoleLogger } from '../log/commonLogger.js';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 /**
  * Only supports Sync functions.
@@ -5,7 +6,7 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
  */
 export function _memoized(fn, opt = {}) {
-    const { logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logger = consoleLogger, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const memoizedFn = function (...args) {
         const ctx = this;
@@ -18,7 +19,7 @@ export function _memoized(fn, opt = {}) {
             cache.set(cacheKey, value);
         }
         catch (err) {
-            logger.error(err);
+            logger.error({ err });
         }
         return value;
     };

package/dist/decorators/memoizedAsync.js

@@ -1,7 +1,8 @@
+import { consoleLogger } from '../log/commonLogger.js';
 import { MISS } from '../types.js';
 import { jsonMemoSerializer } from './memo.util.js';
 export function _memoizedAsync(fn, opt) {
-    const { logger = console, cacheFactory, cacheKeyFn = jsonMemoSerializer } = opt;
+    const { logger = consoleLogger, cacheFactory, cacheKeyFn = jsonMemoSerializer } = opt;
     const cache = cacheFactory();
     const memoizedFn = async function (...args) {
         const ctx = this;
@@ -11,7 +12,7 @@ export function _memoizedAsync(fn, opt) {
             value = await cache.get(cacheKey);
         }
         catch (err) {
-            logger.error(err);
+            logger.error({ err });
         }
         if (value !== MISS) {
             return value;
@@ -22,7 +23,7 @@ export function _memoizedAsync(fn, opt) {
                 await cache.set(cacheKey, value);
             }
             catch (err) {
-                logger.error(err);
+                logger.error({ err });
             }
         })();
         return value;

package/dist/error/tryCatch.d.ts

@@ -15,7 +15,7 @@ export interface TryCatchOptions {
      */
     logError?: boolean;
     /**
-     * Default to `console`
+     * Default to `consoleLogger`
      */
     logger?: CommonLogger;
 }

package/dist/error/tryCatch.js

@@ -1,4 +1,5 @@
 import { _since } from '../datetime/time.util.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { _anyToError } from './error.util.js';
 /**
  * Decorates a function with "try/catch", so it'll never reject/throw.
@@ -9,7 +10,7 @@ import { _anyToError } from './error.util.js';
  * @experimental
  */
 export function _tryCatch(fn, opt = {}) {
-    const { onError, logError = true, logSuccess = false, logger = console } = opt;
+    const { onError, logError = true, logSuccess = false, logger = consoleLogger } = opt;
     const fname = fn.name || 'anonymous';
     return async function (...args) {
         const started = Date.now();
@@ -22,7 +23,7 @@ export function _tryCatch(fn, opt = {}) {
         }
         catch (err) {
             if (logError) {
-                logger.warn(`tryCatch.${fname} error in ${_since(started)}:`, err);
+                logger.warn({ msg: `tryCatch.${fname} error in ${_since(started)}`, err });
             }
             if (onError) {
                 try {

package/dist/http/fetcher.js

@@ -6,13 +6,13 @@ import { _ms, _since } from '../datetime/time.util.js';
 import { isServerSide } from '../env.js';
 import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert.js';
 import { _anyToError, _anyToErrorObject, _errorDataAppend, _errorLikeToErrorObject, HttpRequestError, UnexpectedPassError, } from '../error/error.util.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { _clamp } from '../number/number.util.js';
 import { _filterFalsyValues, _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util.js';
 import { pDelaySignal } from '../promise/pDelay.js';
 import { pTimeout } from '../promise/pTimeout.js';
 import { _toUrlOrNull } from '../string/index.js';
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util.js';
-import { _stringify } from '../string/stringify.js';
 import { HTTP_METHODS } from './http.model.js';
 /**
  * Experimental wrapper around Fetch.
@@ -326,7 +326,7 @@ export class Fetcher {
                     .filter(Boolean)
                     .join(' '));
                 if (req.logRequestBody && req.init.body) {
-                    logger.log(req.init.body); // todo: check if we can _inspect it
+                    logger.log({ body: req.init.body }); // todo: check if we can _inspect it
                 }
             }
             try {
@@ -473,7 +473,7 @@ export class Fetcher {
                 .filter(Boolean)
                 .join(' '));
             if (req.logResponseBody && res.body !== undefined) {
-                logger.log(res.body);
+                logger.log({ body: res.body });
             }
         }
     }
@@ -558,19 +558,20 @@ export class Fetcher {
         // lastError = retryStatus.retryStopped
         // We need to log the response "anyway" if logResponse is true
         if (res.err && (!retryStatus.retryStopped || res.req.logResponse)) {
-            this.cfg.logger.error([
-                ' <<',
-                res.fetchResponse?.status || 0,
-                res.signature,
-                count &&
-                    (retryStatus.retryAttempt || !retryStatus.retryStopped) &&
-                    `try#${retryStatus.retryAttempt + 1}/${count + 1}`,
-                _since(res.req.started),
-            ]
-                .filter(Boolean)
-                .join(' ') + '\n', 
-            // We're stringifying the error here, otherwise Sentry shows it as [object Object]
-            _stringify(res.err.cause || res.err));
+            this.cfg.logger.error({
+                msg: [
+                    ' <<',
+                    res.fetchResponse?.status || 0,
+                    res.signature,
+                    count &&
+                        (retryStatus.retryAttempt || !retryStatus.retryStopped) &&
+                        `try#${retryStatus.retryAttempt + 1}/${count + 1}`,
+                    _since(res.req.started),
+                ]
+                    .filter(Boolean)
+                    .join(' '),
+                err: res.err.cause || res.err,
+            });
         }
         if (retryStatus.retryStopped)
             return;
@@ -704,7 +705,7 @@ export class Fetcher {
         return shortUrl;
     }
     normalizeCfg(cfg) {
-        const { debug = false, logger = console } = cfg;
+        const { debug = false, logger = consoleLogger } = cfg;
         if (cfg.baseUrl?.endsWith('/')) {
             logger.warn(`Fetcher: baseUrl should not end with slash: ${cfg.baseUrl}`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);

package/dist/http/fetcher.model.d.ts

@@ -124,7 +124,7 @@ export interface FetcherCfg {
      */
     logWithSearchParams?: boolean;
     /**
-     * Defaults to `console`.
+     * Defaults to `consoleLogger`.
      */
     logger?: CommonLogger;
     throwHttpErrors?: boolean;

package/dist/log/commonLogger.d.ts

@@ -1,4 +1,3 @@
-import type { AnyObject, MutateOptions } from '../types.js';
 /**
  * These levels follow console.* naming,
  * so you can use console[level] safely.
@@ -16,17 +15,27 @@ import type { AnyObject, MutateOptions } from '../types.js';
 export type CommonLogLevel = 'debug' | 'log' | 'warn' | 'error';
 export declare const commonLogLevelNumber: Record<CommonLogLevel, number>;
 /**
- * Function that takes any number of arguments and logs them all.
- * It is expected that logged arguments are separated by "space", like console.log does.
- *
- * @experimental
+ * Structured log data: a message, an error, and any other fields.
  */
-export type CommonLogFunction = (...args: any[]) => void;
-export type CommonLogWithLevelFunction = (level: CommonLogLevel, args: any[]) => void;
+export interface LogData {
+    msg?: string;
+    err?: unknown;
+    [field: string]: unknown;
+}
+/**
+ * What a log call accepts: a string is `{ msg }`, an Error is `{ err }`.
+ * A non-Error error value (e.g an `unknown` from a catch) is passed as `{ err }`.
+ */
+export type LogInput = string | Error | LogData;
+/**
+ * What a sink receives: the logger's context, the log data and the level.
+ */
+export interface LogEntry extends LogData {
+    level: CommonLogLevel;
+}
+export type LogSink = (entry: LogEntry) => void;
+export type CommonLogFunction = (input: LogInput) => void;
 /**
- * Interface is inspired/compatible with `console.*`
- * So, `console` is a valid CommonLogger implementation as-is.
- *
  * @experimental
  */
 export interface CommonLogger {
@@ -34,32 +43,30 @@ export interface CommonLogger {
     log: CommonLogFunction;
     warn: CommonLogFunction;
     error: CommonLogFunction;
+    /**
+     * Creates a logger that adds `context` to every entry.
+     */
+    child: (context: LogData) => CommonLogger;
 }
 /**
- * SimpleLogger that does nothing (noop).
+ * Creates a CommonLogger that writes every entry to `sink`.
+ * `context` is called on every log call, so it can return values that change
+ * after the logger is created (e.g a request context whose user is resolved later).
  */
-export declare const commonLoggerNoop: CommonLogger;
+export declare function commonLoggerCreate(sink: LogSink, context?: () => LogData): CommonLogger;
 /**
- * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
+ * CommonLogger that logs to `console`.
  */
-export declare function createCommonLoggerAtLevel(logger?: CommonLogger, minLevel?: CommonLogLevel, opt?: MutateOptions): CommonLogger;
+export declare const consoleLogger: CommonLogger;
 /**
- * Creates a "proxy" CommonLogger that pipes log messages to all provided sub-loggers.
+ * CommonLogger that does nothing (noop).
  */
-export declare function commonLoggerPipe(loggers: CommonLogger[]): CommonLogger;
+export declare const commonLoggerNoop: CommonLogger;
 /**
- * Creates a "child" CommonLogger with prefix (one or multiple).
+ * Creates a CommonLogger that is "limited" to the specified CommonLogLevel.
  */
-export declare function commonLoggerPrefix(logger: CommonLogger, ...prefixes: any[]): CommonLogger;
-export type CommonLogSink = CommonLogger | CommonLogWithLevelFunction;
-export interface CommonLoggerWithContext extends CommonLogger {
-    child: (context: AnyObject) => CommonLoggerWithContext;
-}
+export declare function createCommonLoggerAtLevel(logger?: CommonLogger, minLevel?: CommonLogLevel): CommonLogger;
 /**
- * Creates a CommonLogger from a single function that takes `level` and `args`.
- *
- * With a context, every call emits one object: plain-object args merged in, first Error as `err`,
- * the rest joined into `msg`.
+ * Creates a "proxy" CommonLogger that pipes log entries to all provided sub-loggers.
  */
-export declare function commonLoggerCreate(sink: CommonLogSink): CommonLogger;
-export declare function commonLoggerCreate(sink: CommonLogSink, context: AnyObject): CommonLoggerWithContext;
+export declare function commonLoggerPipe(loggers: CommonLogger[]): CommonLogger;

package/dist/log/commonLogger.js

@@ -1,117 +1,82 @@
-import { _isPlainObject } from '../is.util.js';
 // copy-pasted to avoid weird circular dependency
 const _noop = (..._args) => undefined;
 export const commonLogLevelNumber = {
     debug: 10,
     log: 20,
-    warn: 20,
-    error: 30,
+    warn: 30,
+    error: 40,
 };
 /**
- * SimpleLogger that does nothing (noop).
+ * Creates a CommonLogger that writes every entry to `sink`.
+ * `context` is called on every log call, so it can return values that change
+ * after the logger is created (e.g a request context whose user is resolved later).
+ */
+export function commonLoggerCreate(sink, context) {
+    const emit = (level, input) => sink({ ...context?.(), ...toLogData(input), level });
+    return {
+        debug: input => emit('debug', input),
+        log: input => emit('log', input),
+        warn: input => emit('warn', input),
+        error: input => emit('error', input),
+        child: childContext => commonLoggerCreate(sink, () => ({ ...context?.(), ...childContext })),
+    };
+}
+function toLogData(input) {
+    if (typeof input === 'string')
+        return { msg: input };
+    if (input instanceof Error)
+        return { err: input };
+    return input;
+}
+/**
+ * CommonLogger that logs to `console`.
+ */
+export const consoleLogger = commonLoggerCreate(({ level, msg, err, ...fields }) => {
+    const args = [];
+    if (msg !== undefined)
+        args.push(msg);
+    if (err !== undefined)
+        args.push(err);
+    if (Object.keys(fields).length)
+        args.push(fields);
+    console[level](...args);
+});
+/**
+ * CommonLogger that does nothing (noop).
  */
 export const commonLoggerNoop = {
     debug: _noop,
     log: _noop,
     warn: _noop,
     error: _noop,
+    child: () => commonLoggerNoop,
 };
 /**
- * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
+ * Creates a CommonLogger that is "limited" to the specified CommonLogLevel.
  */
-export function createCommonLoggerAtLevel(logger = console, minLevel = 'log', opt = {}) {
+export function createCommonLoggerAtLevel(logger = consoleLogger, minLevel = 'log') {
     const level = commonLogLevelNumber[minLevel];
-    if (opt.mutate) {
-        if (level > commonLogLevelNumber['debug']) {
-            logger.debug = _noop;
-            if (level > commonLogLevelNumber['log']) {
-                logger.log = _noop;
-                if (level > commonLogLevelNumber['warn']) {
-                    logger.warn = _noop;
-                    if (level > commonLogLevelNumber['error']) {
-                        logger.error = _noop;
-                    }
-                }
-            }
-        }
-        return logger;
-    }
     if (level <= commonLogLevelNumber['debug']) {
         // All levels are kept
         return logger;
     }
-    if (level > commonLogLevelNumber['error']) {
-        // "Log nothing" logger
-        return commonLoggerNoop;
-    }
     return {
         debug: _noop, // otherwise it is "log everything" logger (same logger as input)
-        log: level <= commonLogLevelNumber['log'] ? logger.log.bind(logger) : _noop,
-        warn: level <= commonLogLevelNumber['warn'] ? logger.warn.bind(logger) : _noop,
-        error: logger.error.bind(logger), // otherwise it's "log nothing" logger (same as noopLogger)
+        log: level <= commonLogLevelNumber['log'] ? input => logger.log(input) : _noop,
+        warn: level <= commonLogLevelNumber['warn'] ? input => logger.warn(input) : _noop,
+        error: input => logger.error(input),
+        child: context => createCommonLoggerAtLevel(logger.child(context), minLevel),
     };
 }
 /**
- * Creates a "proxy" CommonLogger that pipes log messages to all provided sub-loggers.
+ * Creates a "proxy" CommonLogger that pipes log entries to all provided sub-loggers.
  */
 export function commonLoggerPipe(loggers) {
     return {
-        debug: (...args) => loggers.forEach(logger => logger.debug(...args)),
-        log: (...args) => loggers.forEach(logger => logger.log(...args)),
-        warn: (...args) => loggers.forEach(logger => logger.warn(...args)),
-        error: (...args) => loggers.forEach(logger => logger.error(...args)),
+        debug: input => loggers.forEach(logger => logger.debug(input)),
+        log: input => loggers.forEach(logger => logger.log(input)),
+        warn: input => loggers.forEach(logger => logger.warn(input)),
+        error: input => loggers.forEach(logger => logger.error(input)),
+        child: context => commonLoggerPipe(loggers.map(logger => logger.child(context))),
     };
 }
-/**
- * Creates a "child" CommonLogger with prefix (one or multiple).
- */
-export function commonLoggerPrefix(logger, ...prefixes) {
-    return {
-        debug: (...args) => logger.debug(...prefixes, ...args),
-        log: (...args) => logger.log(...prefixes, ...args),
-        warn: (...args) => logger.warn(...prefixes, ...args),
-        error: (...args) => logger.error(...prefixes, ...args),
-    };
-}
-export function commonLoggerCreate(sink, context) {
-    const fn = typeof sink === 'function' ? sink : (level, args) => sink[level](...args);
-    if (!context) {
-        return {
-            debug: (...args) => fn('debug', args),
-            log: (...args) => fn('log', args),
-            warn: (...args) => fn('warn', args),
-            error: (...args) => fn('error', args),
-        };
-    }
-    const ctx = { ...context };
-    const logger = {
-        debug: (...args) => fn('debug', [toLogEntry(ctx, args)]),
-        log: (...args) => fn('log', [toLogEntry(ctx, args)]),
-        warn: (...args) => fn('warn', [toLogEntry(ctx, args)]),
-        error: (...args) => fn('error', [toLogEntry(ctx, args)]),
-        child: c => commonLoggerCreate(fn, { ...ctx, ...c }),
-    };
-    return logger;
-}
-function toLogEntry(context, args) {
-    const entry = { ...context };
-    let err;
-    let msg;
-    for (const arg of args) {
-        if (_isPlainObject(arg)) {
-            Object.assign(entry, arg);
-        }
-        else if (!err && arg instanceof Error) {
-            err = arg;
-        }
-        else {
-            const s = String(arg);
-            msg = msg === undefined ? s : `${msg} ${s}`;
-        }
-    }
-    if (err)
-        entry['err'] = err;
-    if (msg !== undefined)
-        entry['msg'] = msg;
-    return entry;
-}

package/dist/promise/pGradualQueue.d.ts

@@ -19,7 +19,7 @@ export interface PGradualQueueCfg {
      */
     errorMode?: ErrorMode;
     /**
-     * Default to `console`
+     * Default to `consoleLogger`
      */
     logger?: CommonLogger;
     /**

package/dist/promise/pMap.d.ts

@@ -14,11 +14,11 @@ export interface PMapOptions {
      * When set to THROW_AGGREGATED, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an Aggregated error.
      *
      * When set to SUPPRESS - will ignore errors and return results from successful operations.
-     * When in SUPPRESS - errors are still logged via the `logger` (which defaults to console).
+     * When in SUPPRESS - errors are still logged via the `logger` (which defaults to consoleLogger).
      */
     errorMode?: ErrorMode;
     /**
-     * Default to `console`.
+     * Default to `consoleLogger`.
      * Pass `null` to skip logging completely.
      */
     logger?: CommonLogger | null;

package/dist/promise/pMap.js

@@ -1,4 +1,5 @@
 import { ErrorMode } from '../error/errorMode.js';
+import { consoleLogger } from '../log/commonLogger.js';
 import { END, SKIP } from '../types.js';
 /**
  * Forked from https://github.com/sindresorhus/p-map
@@ -39,7 +40,7 @@ export async function pMap(iterable, mapper, opt = {}) {
     const itemsLength = items.length;
     if (itemsLength === 0)
         return []; // short circuit
-    const { concurrency = Infinity, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
+    const { concurrency = Infinity, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = consoleLogger, } = opt;
     // Special cases that are able to preserve async stack traces
     // Special case: serial execution
     if (concurrency === 1) {
@@ -135,7 +136,7 @@ async function pMap1(items, mapper, errorMode, logger) {
             }
             else {
                 // otherwise, suppress (but still log via logger)
-                logger?.error(err);
+                logger?.error({ err });
             }
         }
     }
@@ -165,7 +166,7 @@ async function pMapAll(items, mapper, errorMode, logger) {
         }
         else {
             // otherwise, suppress (but still log via logger)
-            logger?.error(r.reason);
+            logger?.error({ err: r.reason });
         }
     }
     if (errors.length) {

package/dist/promise/pQueue.d.ts

@@ -12,7 +12,7 @@ export interface PQueueCfg {
      */
     errorMode?: ErrorMode;
     /**
-     * Default to `console`
+     * Default to `consoleLogger`
      */
     logger?: CommonLogger;
     /**