standard-log 11.5.1 → 12.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standard-log",
-  "version": "11.5.1",
+  "version": "12.0.0",
   "description": "The standard log library",
   "homepage": "https://github.com/unional/standard-log/tree/main/packages/log",
   "bugs": {
@@ -18,11 +18,17 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    "import": "./esm/index.js",
-    "require": "./cjs/index.js",
-    "default": "./cjs/index.js"
+    "import": {
+      "types": "./esm/index.d.ts",
+      "default": "./esm/index.js"
+    },
+    "require": {
+      "types": "./cjs/index.d.ts",
+      "default": "./cjs/index.js"
+    }
   },
   "main": "./cjs/index.js",
+  "module": "./esm/index.js",
   "browser": {
     "./cjs/platform.js": "./cjs/platform.browser.js",
     "./esm/platform.js": "./esm/platform.browser.js",
@@ -40,13 +46,13 @@
   ],
   "dependencies": {
     "@just-func/types": "^0.5.0",
-    "iso-error": "^5.0.0",
+    "iso-error": "^6.0.0",
     "ms": "^2.1.3",
-    "type-plus": "^5.0.0",
+    "type-plus": "^6.5.0",
     "upper-case": "^2.0.2"
   },
   "devDependencies": {
-    "@repobuddy/jest": "^2.1.0",
+    "@repobuddy/jest": "^3.0.0",
     "@size-limit/preset-small-lib": "^8.1.0",
     "@types/jest": "^29.1.1",
     "@types/ms": "^0.7.31",
@@ -73,7 +79,7 @@
     "ts-jest": "^29.0.3",
     "ts-loader": "^9.4.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.8.4",
+    "typescript": "^5.0.0",
     "webpack": "^5.74.0",
     "webpack-bundle-analyzer": "^4.6.1",
     "webpack-cli": "^5.0.0"

package/ts/console.ts

@@ -1,70 +1,79 @@
 import { unpartial } from 'type-plus'
 import { consoleFormatter } from './formatter.js'
-import { logLevels } from './logLevels.js'
+import { logLevels } from './log_levels.js'
 import { polyfill } from './platform.js'
 import type { ConsoleLike, LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './types.js'
 
 export function toConsoleMethod(level: number) {
-  switch (true) {
-    // edge case in case none is somehow written
-    case (level <= 0): return 'debug'
-    case (level <= logLevels.error): return 'error'
-    case (level <= logLevels.warn): return 'warn'
-    case (level <= logLevels.info): return 'info'
-    default: return 'debug'
-  }
+	switch (true) {
+		// edge case in case none is somehow written
+		case level <= 0:
+			return 'debug'
+		case level <= logLevels.error:
+			return 'error'
+		case level <= logLevels.warn:
+			return 'warn'
+		case level <= logLevels.info:
+			return 'info'
+		default:
+			return 'debug'
+	}
 }
 
 // istanbul ignore next
 /* eslint-disable no-console */
 function buildPolyfillConsole() {
-  // old phantomjs does not have bind function
-  const hasBind = !!console.log.bind as boolean
-  if (hasBind) {
-    return {
-      // the `typeof` guards against IE where `console.log.apply()`
-      // results in error `Object doesn't support property or method 'apply'`
-      debug: (typeof console.info === 'function' ? console.debug : console.log).bind(console),
-      info: (typeof console.info === 'function' ? console.info : console.log).bind(console),
-      warn: (typeof console.warn === 'function' ? console.warn : console.log).bind(console),
-      error: (typeof console.error === 'function' ? console.error : console.log).bind(console)
-    }
-  }
-  else {
-    return {
-      debug: buildFn(typeof console.debug === 'function' ? 'debug' : 'log'),
-      info: buildFn(typeof console.info === 'function' ? 'info' : 'log'),
-      warn: buildFn(typeof console.warn === 'function' ? 'warn' : 'log'),
-      error: buildFn(typeof console.error === 'function' ? 'error' : 'log'),
-    }
-  }
+	// old phantomjs does not have bind function
+	const hasBind = !!console.log.bind as boolean
+	if (hasBind) {
+		return {
+			// the `typeof` guards against IE where `console.log.apply()`
+			// results in error `Object doesn't support property or method 'apply'`
+			debug: (typeof console.info === 'function' ? console.debug : console.log).bind(console),
+			info: (typeof console.info === 'function' ? console.info : console.log).bind(console),
+			warn: (typeof console.warn === 'function' ? console.warn : console.log).bind(console),
+			error: (typeof console.error === 'function' ? console.error : console.log).bind(console)
+		}
+	} else {
+		return {
+			debug: buildFn(typeof console.debug === 'function' ? 'debug' : 'log'),
+			info: buildFn(typeof console.info === 'function' ? 'info' : 'log'),
+			warn: buildFn(typeof console.warn === 'function' ? 'warn' : 'log'),
+			error: buildFn(typeof console.error === 'function' ? 'error' : 'log')
+		}
+	}
 }
 
 // istanbul ignore next
 function buildFn(name: 'debug' | 'info' | 'warn' | 'error' | 'log') {
-  return function (...args: any[]) { console[name](...args) }
+	return function (...args: any[]) {
+		console[name](...args)
+	}
 }
 
-
 export type ConsoleLogFormatter = LogFormatter<any[]>
 export type ConsoleLogReporter = LogReporter<any[]> & { console: ConsoleLike }
 export type ConsoleLogReporterOptions = LogReporterOptions<any[]>
 
 export function createConsoleLogReporter(options?: ConsoleLogReporterOptions): ConsoleLogReporter {
-  const { id, formatter, filter } = unpartial({ id: 'console', formatter: consoleFormatter }, options)
-  if (!polyfill.console) polyfill.console = buildPolyfillConsole()
+	const { id, formatter, filter } = unpartial({ id: 'console', formatter: consoleFormatter }, options)
+	if (!polyfill.console) polyfill.console = buildPolyfillConsole()
 
-  return Object.freeze({
-    id,
-    isConsoleReporter: true,
-    get formatter() { return formatter },
-    get filter() { return filter },
-    console: polyfill.console,
-    write(entry: LogEntry) {
-      if (filter && !filter(entry)) return
-      const values = formatter(entry)
-      const method = toConsoleMethod(entry.level)
-      this.console[method](...values)
-    }
-  })
+	return Object.freeze({
+		id,
+		isConsoleReporter: true,
+		get formatter() {
+			return formatter
+		},
+		get filter() {
+			return filter
+		},
+		console: polyfill.console,
+		write(entry: LogEntry) {
+			if (filter && !filter(entry)) return
+			const values = formatter(entry)
+			const method = toConsoleMethod(entry.level)
+			this.console[method](...values)
+		}
+	})
 }

package/ts/errors.ts

@@ -4,16 +4,16 @@ import { IsoError, ModuleError } from 'iso-error'
  * @deprecated No longer used since 11.2.0
  */
 export class StandardLogError extends ModuleError {
-  constructor(description: string, options?: IsoError.Options) {
-    super('standard-log', description, options)
-  }
+	constructor(description: string, options?: IsoError.Options) {
+		super('standard-log', description, options)
+	}
 }
 
 /**
  * @deprecated no longer used since 11.2.0
  */
 export class InvalidId extends StandardLogError {
-  constructor(public id: string, options?: IsoError.Options) {
-    super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options)
-  }
+	constructor(public id: string, options?: IsoError.Options) {
+		super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options)
+	}
 }

package/ts/formatter.ts

@@ -1,30 +1,30 @@
 import ms from 'ms'
 import { upperCase } from 'upper-case'
-import { toLogLevelName } from './logLevels.js'
+import { toLogLevelName } from './log_levels.js'
 import type { LogEntry } from './types.js'
 
 export type TimestampFormat = 'none' | 'iso' | 'elapsed'
 
 export function createTimestampFormatter(format: TimestampFormat): (timestamp: Date) => string | undefined {
-  switch (format) {
-    case 'none':
-      return (_timestamp: Date) => undefined
-    case 'iso':
-      return (timestamp: Date) => timestamp.toISOString()
-    case 'elapsed': {
-      let lastTick: number
-      return (timestamp: Date) => {
-        const newTick = timestamp.getTime()
-        const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
-        lastTick = newTick
-        return result
-      }
-    }
-  }
+	switch (format) {
+		case 'none':
+			return (_timestamp: Date) => undefined
+		case 'iso':
+			return (timestamp: Date) => timestamp.toISOString()
+		case 'elapsed': {
+			let lastTick: number
+			return (timestamp: Date) => {
+				const newTick = timestamp.getTime()
+				const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
+				lastTick = newTick
+				return result
+			}
+		}
+	}
 }
 
 export function formatLogLevel(level: number) {
-  return `(${upperCase(toLogLevelName(level))})`
+	return `(${upperCase(toLogLevelName(level))})`
 }
 
 /**
@@ -34,12 +34,12 @@ export function formatLogLevel(level: number) {
  * This is typically useful for writing logs to file
  */
 export function plainLogFormatter({ id, level, args, timestamp }: LogEntry) {
-  return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
+	return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
 }
 
 /**
  * Formats log entry like default console log.
  */
 export function consoleFormatter({ args }: LogEntry) {
-  return args
+	return args
 }

package/ts/index.ts

@@ -1,16 +1,25 @@
 export * from './console.js'
 export * from './errors.js'
 export * from './formatter.js'
-export * from './logLevels.js'
+export * from './log_levels.js'
 export * from './memory.js'
-export {
-  configGlobal, createStandardLog, createStandardLogForTest,
-  getLogger, suppressLogs
-} from './standardLog.js'
-export type { GetLogger, StandardLog, StandardLogForTest } from './standardLog.js'
+export { configGlobal, createStandardLog, getLogger, suppressLogs } from './standard_log.js'
+export type { GetLogger, StandardLog } from './standard_log.js'
 export type {
-  ConsoleLike, LogEntry, LogFilter, LogFormatter, LogFunction, Logger, LoggerOptions, LogLevel,
-  LogLevelEntry, LogMethod, LogMethodNames, LogReporter, LogReporterOptions, ReporterFilter,
-  StandardLogInstance, StandardLogOptions
+	ConsoleLike,
+	LogEntry,
+	LogFilter,
+	LogFormatter,
+	LogFunction,
+	LogLevel,
+	LogLevelEntry,
+	LogMethod,
+	LogMethodNames,
+	LogReporter,
+	LogReporterOptions,
+	Logger,
+	LoggerOptions,
+	ReporterFilter,
+	StandardLogInstance,
+	StandardLogOptions
 } from './types.js'
-

package/ts/log_levels.ts

@@ -0,0 +1,107 @@
+export const logLevels = {
+	/**
+	 * none: 0
+	 */
+	none: 0 as const,
+	/**
+	 * emergency: 100
+	 *
+	 * emergency -> alert
+	 */
+	emergency: 100 as const,
+	/**
+	 * alert: 200
+	 *
+	 * emergency -> alert -> critical
+	 */
+	alert: 200 as const,
+	/**
+	 * critical: 300
+	 *
+	 * alert -> critical -> error
+	 */
+	critical: 300 as const,
+	/**
+	 * error: 400
+	 *
+	 * critical -> error -> warn
+	 */
+	error: 400 as const,
+	/**
+	 * warn: 500
+	 *
+	 * error -> warn -> notice
+	 */
+	warn: 500 as const,
+	/**
+	 * notice: 600
+	 *
+	 * warn -> notice -> info
+	 */
+	notice: 600 as const,
+	/**
+	 * info: 700
+	 *
+	 * notice -> info -> debug
+	 */
+	info: 700 as const,
+	/**
+	 * debug: 800
+	 *
+	 * info -> debug -> trace
+	 */
+	debug: 800 as const,
+	/**
+	 * trace: 900
+	 *
+	 * debug -> trace -> planck
+	 */
+	trace: 900 as const,
+	/**
+	 * planck: Infinity
+	 * `planck unit` is a very small unit <https://en.wikipedia.org/wiki/Planck_units>.
+	 *
+	 * trace -> planck
+	 */
+	planck: Infinity,
+	/**
+	 * all: Infinity
+	 */
+	all: Infinity
+}
+
+/**
+ * Convert default log level value to log level name.
+ */
+export function toLogLevelName(level: number) {
+	if (level <= 100) return 'emergency'
+	if (level <= 200) return 'alert'
+	if (level <= 300) return 'critical'
+	if (level <= 400) return 'error'
+	if (level <= 500) return 'warn'
+	if (level <= 600) return 'notice'
+	if (level <= 700) return 'info'
+	if (level <= 800) return 'debug'
+	if (level <= 900) return 'trace'
+	return 'planck'
+}
+
+/**
+ * Convert default log level name to log level value.
+ */
+export function toLogLevel(name: string): number | undefined {
+	return (logLevels as any)[name.toLocaleLowerCase()]
+}
+
+export const DEFAULT_LOG_METHOD_NAMES: string[] = [
+	'emergency',
+	'alert',
+	'critical',
+	'error',
+	'warn',
+	'notice',
+	'info',
+	'debug',
+	'trace',
+	'planck'
+]

package/ts/log_store.ts

@@ -0,0 +1,63 @@
+import { mapKey, record, reduceByKey, reduceKey } from 'type-plus'
+import { createConsoleLogReporter } from './console.js'
+import { logLevels, toLogLevel, toLogLevelName } from './log_levels.js'
+import type { Logger, LogLevel, LogMethodNames, LogReporter, StandardLogOptions } from './types.js'
+
+export function createLogStore<N extends string = LogMethodNames>(
+	options: Required<StandardLogOptions<N>>
+): LogStore {
+	return {
+		loggers: record(),
+		nonConsoleLoggers: record(),
+		reporters: options.reporters || [createConsoleLogReporter()],
+		logLevel: options.logLevel,
+		logLevelStore: logLevelStore(options)
+	}
+}
+
+export interface LogStore {
+	loggers: Record<string, Logger>
+	nonConsoleLoggers: Record<string, Logger>
+	reporters: LogReporter[]
+	logLevel: LogLevel
+	logLevelStore: ReturnType<typeof logLevelStore>
+}
+
+export interface LogLevelStoreOptions {
+	customLevels?: Record<string, number>
+}
+
+export function logLevelStore(options: LogLevelStoreOptions) {
+	const customLevels = options.customLevels || record()
+
+	const store = {
+		customLevels,
+		customLevelsReverse: reduceByKey(
+			customLevels,
+			(p, k) => {
+				p[customLevels[k]] = k
+				return p
+			},
+			{} as Record<number, string>
+		)
+	}
+	return {
+		getName(level: number) {
+			return store.customLevelsReverse[level] ?? toLogLevelName(level)
+		},
+		getLevel(name: string) {
+			return store.customLevels[name] ?? toLogLevel(name)
+		},
+		getAllLevels() {
+			return reduceKey(
+				logLevels,
+				(result, name) => {
+					if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
+
+					return result
+				},
+				mapKey(store.customLevels, name => ({ name, level: store.customLevels[name] }))
+			)
+		}
+	}
+}

package/ts/logger.ts

@@ -1,74 +1,84 @@
-import { logLevels } from './logLevels.js'
-import { LogStore } from './logStore.js'
+import { logLevels } from './log_levels.js'
+import { LogStore } from './log_store.js'
 import type { LogEntry, LogFunction, Logger, LoggerOptions, LogMethodNames, LogReporter } from './types.js'
 import { LogLevel } from './types.js'
 
 export function createLogger<N extends string = LogMethodNames>(
-  store: LogStore, id: string, options?: LoggerOptions
+	store: LogStore,
+	id: string,
+	options?: LoggerOptions
 ): Logger<N | LogMethodNames> {
-  id = sanitizeId(id)
-  const writeTo = options?.writeTo ?? (() => true)
-  const [filter, reporters]: [(reporterId: string) => boolean, LogReporter[]] = typeof writeTo === 'string'
-    ? [id => id === writeTo, store.reporters]
-    : writeTo instanceof RegExp
-      ? [id => writeTo.test(id), store.reporters]
-      : typeof writeTo === 'function'
-        ? [writeTo, store.reporters]
-        : [() => true, [writeTo]]
+	id = sanitizeId(id)
+	const writeTo = options?.writeTo ?? (() => true)
+	const [filter, reporters]: [(reporterId: string) => boolean, LogReporter[]] =
+		typeof writeTo === 'string'
+			? [id => id === writeTo, store.reporters]
+			: writeTo instanceof RegExp
+			? [id => writeTo.test(id), store.reporters]
+			: typeof writeTo === 'function'
+			? [writeTo, store.reporters]
+			: [() => true, [writeTo]]
 
-  function write(entry: LogEntry) {
-    writeToReporters(reporters, entry, filter)
-  }
+	function write(entry: LogEntry) {
+		writeToReporters(reporters, entry, filter)
+	}
 
-  const logger = {
-    level: options?.level,
-    write
-  } as any
+	const logger = {
+		level: options?.level,
+		write
+	} as any
 
-  Object.defineProperties(logger, {
-    id: { value: id, writable: false },
-    count: {
-      writable: false,
-      value: ((counter) => (...args: any[]) => {
-        if (shouldLog(store, logLevels.debug, logger.level))
-          write({
-            id,
-            level: logLevels.debug,
-            args: [++counter, ...args],
-            timestamp: new Date()
-          })
-      })(0)
-    },
-    on: {
-      writable: false,
-      value: (level: number | N | LogMethodNames, logFn: LogFunction) => {
-        const logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level)! : level
-        if (shouldLog(store, logLevel, logger.level)) {
-          const methodName = store.logLevelStore.getName(logLevel)
-          const bindedMethod = logger[methodName].bind(logger)
-          const result = logFn(bindedMethod, logger.level ?? store.logLevel)
-          if (result) bindedMethod(result)
-        }
-      }
-    }
-  })
-  store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
-    Object.defineProperty(logger, name, {
-      writable: false,
-      value: (...args: any[]) => {
-        if (shouldLog(store, level, logger.level)) write({ id, level, args, timestamp: new Date() })
-      }
-    })
-  })
-  return logger
+	Object.defineProperties(logger, {
+		id: { value: id, writable: false },
+		count: {
+			writable: false,
+			value: (
+				counter =>
+				(...args: any[]) => {
+					if (shouldLog(store, logLevels.debug, logger.level))
+						write({
+							id,
+							level: logLevels.debug,
+							args: [++counter, ...args],
+							timestamp: new Date()
+						})
+				}
+			)(0)
+		},
+		on: {
+			writable: false,
+			value: (level: number | N | LogMethodNames, logFn: LogFunction) => {
+				const logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level)! : level
+				if (shouldLog(store, logLevel, logger.level)) {
+					const methodName = store.logLevelStore.getName(logLevel)
+					const bindedMethod = logger[methodName].bind(logger)
+					const result = logFn(bindedMethod, logger.level ?? store.logLevel)
+					if (result) bindedMethod(result)
+				}
+			}
+		}
+	})
+	store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
+		Object.defineProperty(logger, name, {
+			writable: false,
+			value: (...args: any[]) => {
+				if (shouldLog(store, level, logger.level)) write({ id, level, args, timestamp: new Date() })
+			}
+		})
+	})
+	return logger
 }
 
 function sanitizeId(id: string) {
-  return id.replace(/[`~!#$%^&*()=+[\]{},|<>?]/g, '-')
+	return id.replace(/[`~!#$%^&*()=+[\]{},|<>?]/g, '-')
 }
 
-function writeToReporters(reporters: LogReporter[], logEntry: LogEntry, filter: (reporterId: string) => boolean) {
-  reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
+function writeToReporters(
+	reporters: LogReporter[],
+	logEntry: LogEntry,
+	filter: (reporterId: string) => boolean
+) {
+	reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
 }
 
 /**
@@ -77,5 +87,5 @@ function writeToReporters(reporters: LogReporter[], logEntry: LogEntry, filter:
  * It can be undefined which the global log level will be used.
  */
 function shouldLog(store: LogStore, targetLevel: LogLevel, loggerLevel: LogLevel | undefined) {
-  return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel)
+	return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel)
 }