@naturalcycles/js-lib 14.64.0 → 14.68.0

package/src/error/tryCatch.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny } from '../index'
+import { _since, _stringifyAny, CommonLogger } from '../index'
 import { AnyFunction } from '../types'
 
 export interface TryCatchOptions {
@@ -17,6 +17,11 @@ export interface TryCatchOptions {
    * @default true
    */
   logError?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
 }
 
 /**
@@ -28,10 +33,7 @@ export interface TryCatchOptions {
  * @experimental
  */
 export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {}): T {
-  const { onError, logError, logSuccess } = {
-    logError: true,
-    ...opt,
-  }
+  const { onError, logError = true, logSuccess = false, logger = console } = opt
 
   const fname = fn.name || 'anonymous'
 
@@ -42,13 +44,13 @@ export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {
       const r = await fn.apply(this, args)
 
       if (logSuccess) {
-        console.log(`tryCatch.${fname} succeeded in ${_since(started)}`)
+        logger.log(`tryCatch.${fname} succeeded in ${_since(started)}`)
       }
 
       return r
     } catch (err) {
       if (logError) {
-        console.warn(
+        logger.warn(
           `tryCatch.${fname} error in ${_since(started)}:\n${_stringifyAny(err, {
             includeErrorData: true,
           })}`,

package/src/index.ts

@@ -228,9 +228,11 @@ import {
   CommonLogLevel,
   CommonLogFunction,
   CommonLogger,
-  SimpleLogger,
-  createSimpleLogger,
-  noopLogger,
+  commonLoggerMinLevel,
+  commonLoggerNoop,
+  commonLogLevelNumber,
+  commonLoggerPipe,
+  commonLoggerPrefix,
 } from './log/commonLogger'
 import { _safeJsonStringify } from './string/safeJsonStringify'
 
@@ -307,7 +309,6 @@ export type {
   CommonLogLevel,
   CommonLogFunction,
   CommonLogger,
-  SimpleLogger,
 }
 
 export {
@@ -466,7 +467,10 @@ export {
   _defineLazyProperty,
   _defineLazyProps,
   _lazyValue,
-  createSimpleLogger,
-  noopLogger,
+  commonLoggerMinLevel,
+  commonLoggerNoop,
+  commonLogLevelNumber,
+  commonLoggerPipe,
+  commonLoggerPrefix,
   _safeJsonStringify,
 }

package/src/log/commonLogger.ts

@@ -1,3 +1,5 @@
+import { _noop } from '../index'
+
 /**
  * These levels follow console.* naming,
  * so you can use console[level] safely.
@@ -10,6 +12,12 @@
  */
 export type CommonLogLevel = 'log' | 'warn' | 'error'
 
+export const commonLogLevelNumber: Record<CommonLogLevel, number> = {
+  log: 10,
+  warn: 20,
+  error: 30,
+}
+
 /**
  * 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.
@@ -31,35 +39,73 @@ export interface CommonLogger {
 }
 
 /**
- * Same as CommonLogger, but also is a "convenience function" itself.
- * So you can do `logger('hey')` which is the same as `logger.log('hey')`
+ * SimpleLogger that does nothing (noop).
  *
  * @experimental
  */
-export interface SimpleLogger extends CommonLogFunction, CommonLogger {}
+export const commonLoggerNoop: CommonLogger = {
+  log: _noop,
+  warn: _noop,
+  error: _noop,
+}
 
 /**
- * Creates a SimpleLogger from CommonLogger.
- *
- * @experimental
+ * Creates a "child" logger that is "limited" to the specified CommonLogLevel.
  */
-export function createSimpleLogger(logger: CommonLogger): SimpleLogger {
-  return Object.assign(((...args: any[]) => logger.log(...args)) as any, {
-    log: (...args: any[]) => logger.log(...args),
-    warn: (...args: any[]) => logger.warn(...args),
-    error: (...args: any[]) => logger.error(...args),
-  })
+export function commonLoggerMinLevel(
+  logger: CommonLogger,
+  minLevel: CommonLogLevel,
+  mutate = false,
+): CommonLogger {
+  const level = commonLogLevelNumber[minLevel]
+  if (mutate) {
+    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['log']) {
+    // All levels are kept
+    return logger
+  }
+
+  if (level > commonLogLevelNumber['error']) {
+    // "Log nothing" logger
+    return commonLoggerNoop
+  }
+
+  return {
+    log: _noop, // otherwise it is "log everything" logger (same logger as input)
+    warn: level <= commonLogLevelNumber['warn'] ? logger.warn.bind(logger) : _noop,
+    error: logger.error.bind(logger), // otherwise it's "log nothing" logger (same as noopLogger)
+  }
 }
 
-const noop = () => {}
+/**
+ * Creates a "proxy" CommonLogger that pipes log messages to all provided sub-loggers.
+ */
+export function commonLoggerPipe(loggers: CommonLogger[]): CommonLogger {
+  return {
+    log: (...args) => loggers.forEach(logger => logger.log(...args)),
+    warn: (...args) => loggers.forEach(logger => logger.warn(...args)),
+    error: (...args) => loggers.forEach(logger => logger.error(...args)),
+  }
+}
 
 /**
- * SimpleLogger that does nothing (noop).
- *
- * @experimental
+ * Creates a "child" CommonLogger with prefix (one or multiple).
  */
-export const noopLogger: SimpleLogger = createSimpleLogger({
-  log: noop,
-  warn: noop,
-  error: noop,
-})
+export function commonLoggerPrefix(logger: CommonLogger, ...prefixes: any[]): CommonLogger {
+  return {
+    log: (...args) => logger.log(...prefixes, ...args),
+    warn: (...args) => logger.warn(...prefixes, ...args),
+    error: (...args) => logger.error(...prefixes, ...args),
+  }
+}

package/src/promise/pRetry.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny } from '..'
+import { _since, _stringifyAny, CommonLogger } from '..'
 
 export interface PRetryOptions {
   /**
@@ -63,6 +63,11 @@ export interface PRetryOptions {
    * @default false
    */
   logNone?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
 }
 
 /**
@@ -71,7 +76,13 @@ export interface PRetryOptions {
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
-  const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate } = opt
+  const {
+    maxAttempts = 4,
+    delay: initialDelay = 1000,
+    delayMultiplier = 2,
+    predicate,
+    logger = console,
+  } = opt
 
   let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt
 
@@ -95,18 +106,18 @@ export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
         try {
           attempt++
           if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-            console.log(`${fname} attempt #${attempt}...`)
+            logger.log(`${fname} attempt #${attempt}...`)
           }
 
           const r = await fn.apply(this, args)
 
           if (logSuccess) {
-            console.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
+            logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
           }
           resolve(r)
         } catch (err) {
           if (logFailures) {
-            console.warn(
+            logger.warn(
               `${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
                 includeErrorData: true,
               })}`,