standard-log 7.0.2 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standard-log",
-  "version": "7.0.2",
+  "version": "8.0.0",
   "description": "The standard log library",
   "homepage": "https://github.com/unional/standard-log/tree/master/packages/log",
   "bugs": {
@@ -15,46 +15,96 @@
     "name": "Homa Wong",
     "email": "homawong@gmail.com"
   },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "import": "./esm/index.js",
+    "require": "./cjs/index.js"
+  },
+  "main": "./cjs/index.js",
+  "browser": {
+    "./cjs/getDefaultReporter.js": "./cjs/getDefaultReporter.browser.js",
+    "./cjs/getLogModeFromEnvironment.js": "./cjs/getLogModeFromEnvironment.browser.js",
+    "./esm/getDefaultReporter.js": "./esm/getDefaultReporter.browser.js",
+    "./esm/getLogModeFromEnvironment.js": "./esm/getLogModeFromEnvironment.browser.js",
+    "./ts/getDefaultReporter.ts": "./ts/getDefaultReporter.browser.ts",
+    "./ts/getLogModeFromEnvironment.ts": "./ts/getLogModeFromEnvironment.browser.ts"
+  },
+  "typings": "./cjs/index.d.ts",
   "files": [
+    "cjs",
     "dist",
-    "lib",
-    "libm",
-    "src"
+    "esm",
+    "ts",
+    "!ts/**/*.spec.ts"
   ],
-  "main": "lib/index.js",
-  "module": "libm/index.js",
-  "jsnext:main": "libm/index.js",
-  "browser": {
-    "./src/getLogModeFromEnvironment.ts": "./src/getLogModeFromEnvironment.browser.ts",
-    "./lib/getLogModeFromEnvironment.js": "./lib/getLogModeFromEnvironment.browser.js",
-    "./libm/getLogModeFromEnvironment.js": "./libm/getLogModeFromEnvironment.browser.js",
-    "./src/getDefaultReporter.ts": "./src/getDefaultReporter.browser.ts",
-    "./lib/getDefaultReporter.js": "./lib/getDefaultReporter.browser.js",
-    "./libm/getDefaultReporter.js": "./libm/getDefaultReporter.browser.js"
-  },
-  "typings": "lib/index.d.ts",
-  "sideEffects": false,
   "scripts": {
-    "build": "tsc -p tsconfig.lib.json && tsc -p tsconfig.libm.json",
-    "bundle": "webpack",
-    "clean": "rimraf dist lib libm",
+    "build": "npm-run-all build:clean -p build:cjs build:esm build:tslib bundle:es5 bundle:esm",
+    "build:clean": "rimraf .tsbuildinfo || true",
+    "build:cjs": "tsc -p ./tsconfig.cjs.json",
+    "build:esm": "tsc -p ./tsconfig.esm.json",
+    "build:tslib": "tsc -p ./tsconfig.tslib.json",
+    "bundle": "run-p bundle:es5 bundle:esm",
+    "bundle:es5": "webpack -c ./webpack.es5.cjs",
+    "bundle:esm": "webpack -c ./webpack.esm.cjs",
+    "clean": "rimraf dist lib libm cjs esm tslib coverage .tsbuildinfo || true",
     "coverage": "jest --coverage",
-    "depcheck": "dependency-check . --unused --no-dev && dependency-check . --missing --no-dev",
-    "prepublishOnly": "yarn build && yarn bundle",
+    "depcheck": "depcheck",
+    "lint": "cross-env TIMING=1 eslint --ext=ts,js,cjs,mjs .",
+    "size": "size-limit",
     "test": "jest",
-    "verify": "yarn lint && yarn build && yarn depcheck && yarn coverage && yarn bundle",
+    "verify": "npm-run-all clean -p build depcheck lint coverage -s size",
     "watch": "jest --watch"
   },
   "dependencies": {
-    "global-store": "1.0.0-beta.19",
     "is-node": "^1.0.2",
-    "iso-error": "^4.1.0",
+    "iso-error": "^4.3.3",
     "ms": "^2.1.3",
-    "tslib": "^2.3.1",
-    "type-plus": "^4.0.0",
+    "tslib": "^2.4.0",
+    "type-plus": "^4.10.0",
     "upper-case": "^2.0.2"
   },
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^7.0.8",
+    "@types/ms": "^0.7.31",
+    "assertron": "^9.2.3",
+    "compression-webpack-plugin": "^10.0.0",
+    "cross-env": "^7.0.3",
+    "delay": "^5.0.0",
+    "depcheck": "^1.4.3",
+    "eslint": "^8.17.0",
+    "global-store": "1.0.0-beta.21",
+    "jest": "^28.1.0",
+    "npm-run-all": "^4.1.5",
+    "param-case": "^3.0.4",
+    "pascal-case": "^3.1.2",
+    "rimraf": "^3.0.2",
+    "size-limit": "^7.0.8",
+    "ts-jest": "^28.0.4",
+    "ts-loader": "^9.3.0",
+    "typescript": "^4.7.3",
+    "webpack": "^5.73.0",
+    "webpack-bundle-analyzer": "^4.5.0",
+    "webpack-cli": "^4.9.2"
+  },
   "peerDependencies": {
-    "global-store": "1.0.0-beta.19"
-  }
+    "global-store": "*"
+  },
+  "optionalDependencies": {
+    "ramda": "^0.28.0"
+  },
+  "size-limit": [
+    {
+      "path": "./cjs/index.js",
+      "limit": "20 kB"
+    },
+    {
+      "path": "./esm/index.js",
+      "limit": "10 kB"
+    },
+    {
+      "path": "./tslib/index.js",
+      "limit": "20 kB"
+    }
+  ]
 }

package/ts/captureLogs.ts

@@ -0,0 +1,35 @@
+import { AnyFunction, isPromise } from 'type-plus'
+import { createMemoryLogReporter } from './memory/index.js'
+import { store } from './store.js'
+import { LogEntry, Logger, LogReporter } from './types.js'
+
+export function captureLogs<R>(logger: Logger, funcBlock: () => Promise<R>): Promise<[R, LogEntry[]]>
+export function captureLogs<R>(logger: Logger, funcBlock: () => R): [R, LogEntry[]]
+export function captureLogs(logger: Logger, funcBlock: AnyFunction) {
+  const reporter = createMemoryLogReporter()
+  addRedirect(logger.id, reporter)
+
+  try {
+    const result = funcBlock()
+    if (isPromise(result)) {
+      return result.then((r) => [r, reporter.logs])
+        .finally(() => removeRedirect(logger.id, reporter))
+    }
+    removeRedirect(logger.id, reporter)
+    return [result, reporter.logs]
+  }
+  catch (e) {
+    removeRedirect(logger.id, reporter)
+    throw e
+  }
+}
+
+function addRedirect(id: string, reporter: LogReporter) {
+  const redirect = store.value.redirects[id] || []
+  redirect.push(reporter)
+  store.value.redirects[id] = redirect
+}
+
+function removeRedirect(id: string, reporter: LogReporter) {
+  store.value.redirects[id] = store.value.redirects[id].filter(r => r !== reporter)
+}

package/ts/config.ts

@@ -0,0 +1,57 @@
+import { forEachKey } from 'type-plus'
+import { addCustomLogLevel } from './customLogLevel.js'
+import { ProhibitedDuringProduction } from './errors.js'
+import { getDefaultReporter } from './getDefaultReporter.js'
+import { getLogger } from './getLogger.js'
+import { store } from './store.js'
+import { LogMode, LogReporter } from './types.js'
+
+export type ConfigOptions = {
+  mode: LogMode,
+  customLevels: Record<string, number>,
+  logLevel: number,
+  reporters: LogReporter[]
+}
+
+export const config: { (options?: Partial<ConfigOptions>): void, readonly isLocked: boolean } = function config(options: Partial<ConfigOptions> = {}) {
+  if (store.value.configured) {
+    if (store.value.mode === 'production') {
+      throw new ProhibitedDuringProduction('config')
+    }
+    if (store.value.mode === 'test' && options.mode !== 'test') {
+      const log = getLogger('standard-log')
+      log.warn(`already configured for test, ignoring config() call`)
+      return
+    }
+  }
+
+  if (options.mode) store.value.mode = options.mode
+
+  store.value.logLevel = options.logLevel !== undefined ? options.logLevel : store.value.logLevel
+
+  if (options.customLevels) {
+    const customLevels = options.customLevels
+    forEachKey(customLevels, k => {
+      addCustomLogLevel(k, customLevels[k])
+    })
+  }
+
+  store.value.reporters = options.reporters || [getDefaultReporter()]
+  store.value.configured = true
+
+  if (store.value.mode === 'production') {
+    store.freeze({ ...store.value, reporters: Object.freeze(store.value.reporters) })
+  }
+  else if (store.value.mode === 'development') {
+    console.warn(`'standard-log' is running in 'development' mode. Configuration is not protected.`)
+  }
+} as any
+
+Object.defineProperty(config, 'isLocked', {
+  /**
+   * Gets if the config has already been locked
+   */
+  get() {
+    return store.value.configured
+  }
+})

package/ts/configForTest.ts

@@ -0,0 +1,16 @@
+import { config } from './config.js'
+import { createMemoryLogReporter } from './memory/index.js'
+import { store } from './store.js'
+import { LogLevel } from './types.js'
+
+
+export function configForTest(logLevel?: LogLevel) {
+  store.reset()
+  const reporter = createMemoryLogReporter()
+  config({
+    reporters: [reporter],
+    mode: 'test',
+    logLevel
+  })
+  return { reporter }
+}

package/ts/console/createConsoleLogReporter.ts

@@ -0,0 +1,42 @@
+import { required } from 'type-plus'
+import { plainLogFormatter } from '../formatter/index.js'
+import { LogFormatter, LogReporter, LogReporterOptions, LogFilter } from '../types.js'
+import { assertLogModeIsNotProduction } from '../utils.js'
+import { polyfilledConsole } from './polyfilledConsole.js'
+import { toConsoleMethod } from './toConsoleMethod.js'
+import { Console } from './types.js'
+
+export type ConsoleLogReporter = LogReporter<any[]> & { console: Console }
+export type ConsoleLogFormatter = LogFormatter<any[]>
+export type ConsoleLogReporterOptions = LogReporterOptions<any[]>
+
+export function createConsoleLogReporter(options?: ConsoleLogReporterOptions): ConsoleLogReporter {
+  const opts = required({ id: 'console', formatter: plainLogFormatter }, options)
+  const { id } = opts
+  let { formatter, filter } = opts
+  return {
+    id,
+    isConsoleReporter: true,
+    get formatter() {
+      return formatter
+    },
+    set formatter(value: ConsoleLogFormatter) {
+      assertLogModeIsNotProduction('set Reporter.formatter')
+      formatter = value
+    },
+    get filter() {
+      return filter
+    },
+    set filter(value: LogFilter) {
+      assertLogModeIsNotProduction('set Reporter.filter')
+      filter = value
+    },
+    console: polyfilledConsole,
+    write(entry) {
+      if (filter && !filter(entry)) return
+      const values = formatter(entry)
+      const method = toConsoleMethod(entry.level)
+      this.console[method](...values)
+    }
+  }
+}

package/ts/console/index.ts

@@ -0,0 +1,3 @@
+export * from './createConsoleLogReporter.js'
+export * from './toConsoleMethod.js'
+export * from './types.js'

package/ts/console/isConsoleDebugAvailable.ts

@@ -0,0 +1,11 @@
+import isNode from 'is-node'
+import { semverGt } from './semverGt.js'
+
+// istanbul ignore file
+export function isConsoleDebugAvailable() {
+  if (!isNode) return true
+  // without this, systemJs will complain `process is not defined`
+  if (!global.process) return true
+  const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version
+  return semverGt(versionString, [9, 3, 0])
+}

package/ts/console/polyfilledConsole.ts

@@ -0,0 +1,34 @@
+/* istanbul ignore file */
+import { isConsoleDebugAvailable } from './isConsoleDebugAvailable.js'
+/* eslint-disable no-console */
+
+function buildPolyfillConsole() {
+  // old phantomjs does not have bind function
+  const hasBind = !!console.log.bind as boolean
+  if (hasBind) {
+    return {
+      // Node@9.3 or below has `console.debug = undefined` or it doesn't log
+      // Should use `console.log()` in those case.
+      debug: (isConsoleDebugAvailable() ? console.debug : console.log).bind(console),
+      // the `typeof` guards against IE where `console.log.apply()`
+      // results in error `Object doesn't support property or method 'apply'`
+      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(isConsoleDebugAvailable() ? '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'),
+    }
+  }
+}
+
+function buildFn(name: 'debug' | 'info' | 'warn' | 'error' | 'log') {
+  return function (...args: any[]) { console[name](...args) }
+}
+
+export const polyfilledConsole = buildPolyfillConsole()

package/ts/console/toConsoleMethod.ts

@@ -0,0 +1,18 @@
+import { logLevels } from '../logLevel.js'
+
+export function toConsoleMethod(level: number) {
+  switch (true) {
+    // istanbul ignore next
+    case (level === 0):
+      // edge case in case none is somehow written
+      return 'debug'
+    case (level <= logLevels.error):
+      return 'error'
+    case (level <= logLevels.warn):
+      return 'warn'
+    case (level <= logLevels.info):
+      return 'info'
+    default:
+      return 'debug'
+  }
+}

package/ts/console/types.ts

@@ -0,0 +1,3 @@
+import { polyfilledConsole } from './polyfilledConsole.js'
+
+export type Console = typeof polyfilledConsole

package/ts/customLogLevel.ts

@@ -0,0 +1,35 @@
+import { forEachKey, mapKey } from 'type-plus'
+import { store } from './store.js'
+import { LogLevelEntry } from './types.js'
+
+/**
+ * @param level the `logLevel` number.
+ * You can specify this in the form of `logLevel.<x> + n` to make it more readable.
+ */
+export function addCustomLogLevel(name: string, level: number) {
+  const { customLevels, customLevelsReverse } = store.value
+  customLevels[name] = level
+  customLevelsReverse[level] = name
+  const { loggerClosures } = store.value
+  forEachKey(loggerClosures, id => loggerClosures[id].addMethod(name, level))
+}
+
+export function clearCustomLogLevel() {
+  const { customLevels, customLevelsReverse } = store.value
+  // Don't replace the object would prevent reference divergence
+  forEachKey(customLevels, k => delete customLevels[k])
+  customLevelsReverse.splice(0, customLevelsReverse.length)
+}
+
+export function getCustomLevel(name: string): number | undefined {
+  return store.value.customLevels[name]
+}
+
+export function getCustomLevelName(level: number): string | undefined {
+  return store.value.customLevelsReverse[level]
+}
+
+export function getCustomLevels(): LogLevelEntry[] {
+  const { customLevels } = store.value
+  return mapKey(customLevels, name => ({ name, level: customLevels[name] }))
+}

package/ts/formatter/createTimestampFormatter.ts

@@ -0,0 +1,21 @@
+import ms from 'ms'
+
+export type TimestampFormat = 'none' | 'iso' | 'elapsed'
+
+export function createTimestampFormatter(format: TimestampFormat) {
+  switch (format) {
+    case 'none':
+      return (_timestamp: Date) => undefined
+    case 'iso':
+      return (timestamp: Date) => timestamp.toISOString()
+    case 'elapsed': {
+      let lastTick: number | undefined = undefined
+      return (timestamp: Date) => {
+        const newTick = timestamp.getTime()
+        const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
+        lastTick = newTick
+        return result
+      }
+    }
+  }
+}

package/ts/formatter/formatLogLevel.ts

@@ -0,0 +1,6 @@
+import { upperCase } from 'upper-case'
+import { toLogLevelName } from '../logLevelFn.js'
+
+export function formatLogLevel(level: number) {
+  return `(${upperCase(toLogLevelName(level))})`
+}

package/ts/formatter/index.ts

@@ -0,0 +1,3 @@
+export * from './createTimestampFormatter.js'
+export * from './formatLogLevel.js'
+export * from './plainLogFormatter.js'

package/ts/formatter/plainLogFormatter.ts

@@ -0,0 +1,6 @@
+import { LogEntry } from '../types.js'
+import { formatLogLevel } from './formatLogLevel.js'
+
+export function plainLogFormatter({ id, level, args, timestamp }: LogEntry) {
+  return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
+}

package/ts/getDefaultReporter.browser.ts

@@ -0,0 +1,13 @@
+/* istanbul ignore file */
+import { createConsoleLogReporter } from './console/index.js'
+
+declare const StandardLogColor: any
+
+export function getDefaultReporter() {
+  try {
+    return StandardLogColor.createColorLogReporter()
+  }
+  catch (e) {
+    return createConsoleLogReporter()
+  }
+}

package/ts/getDefaultReporter.ts

@@ -0,0 +1,15 @@
+import { createConsoleLogReporter } from './console/index.js'
+
+export function getDefaultReporter() {
+  try {
+    // tricks webpack to not bundle standard-log-color
+    const c = '-color'
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const colorModule = require('standard-log' + c)
+    return colorModule.createColorLogReporter()
+  }
+  catch (e) {
+    // istanbul ignore next
+    return createConsoleLogReporter()
+  }
+}

package/ts/getLogModeFromEnvironment.browser.ts

@@ -0,0 +1,6 @@
+import { LogMode } from './types.js'
+
+// istanbul ignore next
+export function getLogModeFromEnvironment(): LogMode | undefined {
+  return undefined
+}

package/ts/getLogModeFromEnvironment.ts

@@ -0,0 +1,16 @@
+import { InvalidEnvVar } from './errors.js'
+import { LogMode } from './types.js'
+
+const logModeValues = ['production', 'development', 'test']
+
+export function getLogModeFromEnvironment(): LogMode | undefined {
+  const mode = process.env.STANDARD_LOG
+  if (mode === undefined || isLogMode(mode)) {
+    return mode as LogMode
+  }
+  throw new InvalidEnvVar('STANDARD_LOG', mode, logModeValues)
+}
+
+function isLogMode(mode: string): mode is LogMode {
+  return logModeValues.indexOf(mode) !== -1
+}

package/ts/getLogger.ts

@@ -0,0 +1,92 @@
+import { InvalidId } from './errors.js'
+import { logLevels } from './logLevel.js'
+import { getAllLogLevels, toLogLevel, toLogLevelName } from './logLevelFn.js'
+import { addLogReporterInternal } from './logReporterInternal.js'
+import { shouldLog } from './shouldLog.js'
+import { store } from './store.js'
+import { LogEntry, LogFunction, Logger, LogMethodNames, LogReporter, ReporterFilter } from './types.js'
+import { LoggerClosure } from './typesInternal.js'
+import { writeToReporters } from './writeToReporters.js'
+
+export namespace getLogger {
+  export type Options = {
+    level?: number,
+    writeTo?: LogReporter | ReporterFilter
+  }
+}
+
+export function getLogger<T extends string = LogMethodNames>(
+  id: string, options?: getLogger.Options
+): Logger<T | LogMethodNames> {
+  validateId(id)
+  const loggerClosures = store.value.loggerClosures
+  const loggerClosure: any = loggerClosures[id] ||
+    (loggerClosures[id] = createLoggerClosure<T | LogMethodNames>(id, options))
+  return loggerClosure.logger
+}
+
+function validateId(id: string) {
+  if (/[`~!#$%^&*()=+[\]{},|<>?]/.test(id)) throw new InvalidId(id)
+}
+
+function createLoggerClosure<T extends string>(id: string, { level, writeTo = () => true }: getLogger.Options = {}): LoggerClosure<T> {
+  const filter: (reporterId: string) => boolean = typeof writeTo === 'string'
+    ? id => id === writeTo
+    : writeTo instanceof RegExp
+      ? id => writeTo.test(id)
+      : typeof writeTo === 'function'
+        ? writeTo
+        : (addLogReporterInternal(writeTo), id => id === writeTo.id)
+
+  function write(entry: LogEntry) {
+    writeToReporters(entry, filter)
+  }
+  const logger = {
+    level,
+    write
+  } as any
+
+  Object.defineProperties(logger, {
+    id: { value: id, writable: false },
+    count: {
+      writable: false,
+      value: ((counter) => (...args: any[]) => {
+        const level = logLevels.debug
+        if (shouldLog(level, logger.level))
+          write({
+            id,
+            level,
+            args: [++counter, ...args],
+            timestamp: new Date()
+          })
+      })(0)
+    },
+    on: {
+      writable: false,
+      value: (level: number | T, logFn: LogFunction) => {
+        const logLevel = typeof level === 'string' ? toLogLevel(level)! : level
+        if (shouldLog(logLevel, logger.level)) {
+          const methodName = toLogLevelName(logLevel)
+          const bindedMethod = logger[methodName].bind(logger)
+          const result = logFn(bindedMethod)
+          if (result) bindedMethod(result)
+        }
+      }
+    }
+  })
+  const loggerClosure: LoggerClosure<T> = {
+    addMethod(name, level) {
+      Object.defineProperty(logger, name, {
+        writable: false,
+        value: (...args: any[]) => {
+          if (shouldLog(level, logger.level)) write({ id, level, args, timestamp: new Date() })
+        }
+      })
+    },
+    logger
+  }
+
+  getAllLogLevels().forEach(({ name, level }) => loggerClosure.addMethod(name, level))
+
+  return loggerClosure
+}

package/ts/getLoggers.ts

@@ -0,0 +1,12 @@
+import { filterKey } from 'type-plus'
+import { store } from './store.js'
+import { Logger } from './types.js'
+
+/**
+ * Get loggers based on RegExp.
+ * @param filter RegExp to look for loggers
+ */
+export function getLoggers(filter: RegExp): Logger<any>[] {
+  const { loggerClosures } = store.value
+  return filterKey(loggerClosures, id => filter.test(id)).map(k => loggerClosures[k].logger)
+}

package/ts/index.ts

@@ -0,0 +1,16 @@
+export * from './captureLogs.js'
+export * from './config.js'
+export * from './configForTest.js'
+export * from './console/index.js'
+export * from './customLogLevel.js'
+export * from './errors.js'
+export * from './formatter/index.js'
+export * from './getLogger.js'
+export * from './logLevel.js'
+export * from './logLevelFn.js'
+export * from './logReporter.js'
+export * from './memory/index.js'
+export * from './shouldLog.js'
+export * from './suppressLogs.js'
+export * from './types.js'
+export * from './utils.js'