standard-log 8.0.0 → 9.0.1

package/ts/config.ts

@@ -1,57 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

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

package/ts/console/isConsoleDebugAvailable.ts

@@ -1,11 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/* 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/semverGt.ts

@@ -1,9 +0,0 @@
-// istanbul ignore next
-export function semverGt(versionString: string, version: [number, number, number]) {
-  const actual = versionString.split('.').reverse().reduce((p, v, i) => {
-    p += Number.parseInt(v, 10) * Math.pow(100, i)
-    return p
-  }, 0)
-
-  return actual > (version[0] * 10000 + version[1] * 100 + version[2])
-}

package/ts/console/toConsoleMethod.ts

@@ -1,18 +0,0 @@
-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

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

package/ts/customLogLevel.ts

@@ -1,35 +0,0 @@
-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/formatLogLevel.ts

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

package/ts/formatter/index.ts

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

package/ts/formatter/plainLogFormatter.ts

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/* 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

@@ -1,15 +0,0 @@
-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

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

package/ts/getLogModeFromEnvironment.ts

@@ -1,16 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/logLevelFn.ts

@@ -1,72 +0,0 @@
-import { reduceKey } from 'type-plus'
-import { getCustomLevel, getCustomLevelName, getCustomLevels } from './customLogLevel.js'
-import { getLoggers } from './getLoggers.js'
-import { logLevels } from './logLevel.js'
-import { store } from './store.js'
-import { Logger } from './types.js'
-
-/**
- * Gets the overall log level.
- */
-export function getLogLevel() {
-  return store.value.logLevel
-}
-
-/**
- * Sets the overall log level.
- * If the logger has its own local log level,
- * that will take precedent.
- */
-export function setLogLevel(level: number) {
-  store.value.logLevel = level
-}
-
-/**
- * Sets log levels on specific loggers.
- * This will override the local log level of the loggers.
- */
-export function setLogLevels(filter: RegExp, level: number): Logger<any>[] {
-  return getLoggers(filter).map(log => {
-    log.level = level
-    return log
-  })
-}
-
-export function toLogLevel(name: string): number | undefined {
-  return getCustomLevel(name) || (logLevels as any)[name.toLowerCase()]
-}
-
-export function toLogLevelName(level: number) {
-  const custom = getCustomLevelName(level)
-  if (custom) return custom
-  switch (true) {
-    case (level <= 100):
-      return 'emergency'
-    case (level <= 200):
-      return 'alert'
-    case (level <= 300):
-      return 'critical'
-    case (level <= 400):
-      return 'error'
-    case (level <= 500):
-      return 'warn'
-    case (level <= 600):
-      return 'notice'
-    case (level <= 700):
-      return 'info'
-    case (level <= 800):
-      return 'debug'
-    case (level <= 900):
-      return 'trace'
-    default:
-      return 'planck'
-  }
-}
-
-export function getAllLogLevels() {
-  return reduceKey(logLevels, (result, name) => {
-    if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
-
-    return result
-  }, getCustomLevels())
-}

package/ts/logReporter.ts

@@ -1,26 +0,0 @@
-import { addLogReporterInternal } from './logReporterInternal.js'
-import { store } from './store.js'
-import { LogReporter } from './types.js'
-import { assertLogModeIsNotProduction } from './utils.js'
-
-export function addLogReporter(reporter: LogReporter) {
-  assertLogModeIsNotProduction('addLogReporter')
-  addLogReporterInternal(reporter)
-}
-
-export function getLogReporter(id: string) {
-  return store.value.reporters.find(r => r.id === id)
-}
-
-export function hasConsoleReporter() {
-  return store.value.reporters.some(r => r.isConsoleReporter)
-}
-
-export function getConsoleReporter() {
-  return store.value.reporters.find(r => r.isConsoleReporter)
-}
-
-export function clearLogReporters() {
-  assertLogModeIsNotProduction('clearLogReporters')
-  store.value.reporters.splice(0, store.value.reporters.length)
-}

package/ts/logReporterInternal.ts

@@ -1,18 +0,0 @@
-import { getConsoleReporter } from './logReporter.js'
-import { store } from './store.js'
-import { LogReporter } from './types.js'
-
-export function addLogReporterInternal(reporter: LogReporter) {
-  if (reporter.isConsoleReporter) {
-    const r = getConsoleReporter()
-    if (r && reporter.filter) {
-      const f = r.filter
-      const f2 = reporter.filter
-      if (f) r.filter = entry => f(entry) && f2(entry)
-      else r.filter = f2
-    }
-  }
-  else {
-    store.value.reporters.push(reporter)
-  }
-}

package/ts/memory/MemoryLogReporter.ts

@@ -1,66 +0,0 @@
-import { required } from 'type-plus'
-import { formatLogLevel } from '../formatter/index.js'
-import { LogEntry, LogFilter, LogFormatter, LogReporter, LogReporterOptions } from '../types.js'
-import { assertLogModeIsNotProduction } from '../utils.js'
-import { toInspectLogEntry } from './toInspectStringForObject.js'
-
-export type MemoryLogReporter = LogReporter<LogEntry> & {
-  logs: LogEntry[],
-  /**
-   * Gets a simple log message for testing.
-   * The message only contains arguments for each log entry.
-   */
-  getLogMessage(): string,
-  getLogMessageWithLevel(): string
-}
-
-export type MemoryLogFormatter = LogFormatter<LogEntry>
-
-function createGetLogMessage() {
-  return function getLogMessage(this: { logs: LogEntry[] }) {
-    return this.logs.map(toInspectLogEntry)
-      .map(log => log.args.join(' '))
-      .join('\n')
-  }
-}
-
-export function toMessageWithLevel(logs: LogEntry[]) {
-  return logs.map(toInspectLogEntry)
-    .map(log => `${formatLogLevel(log.level)} ${log.args.join(' ')}`)
-    .join('\n')
-    // if it has more than this log,
-    // we assume it is running under tests,
-    // and remove this log to simplify testing.
-    .replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '')
-}
-
-
-export function createMemoryLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
-  const opt = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
-  const { id } = opt
-  let { formatter, filter } = opt
-  return {
-    id,
-    get formatter() {
-      return formatter
-    },
-    set formatter(value: MemoryLogFormatter) {
-      assertLogModeIsNotProduction('set Reporter.formatter')
-      formatter = value
-    },
-    get filter() {
-      return filter
-    },
-    set filter(value: LogFilter) {
-      assertLogModeIsNotProduction('set Reporter.filter')
-      filter = value
-    },
-    logs: [],
-    write(entry) {
-      if (filter && !filter(entry)) return
-      this.logs.push(formatter(entry))
-    },
-    getLogMessage: createGetLogMessage(),
-    getLogMessageWithLevel() { return toMessageWithLevel(this.logs) }
-  }
-}

package/ts/memory/index.ts

@@ -1,2 +0,0 @@
-export * from './logEntriesToString.js'
-export * from './MemoryLogReporter.js'

package/ts/memory/logEntriesToString.ts

@@ -1,7 +0,0 @@
-import { plainLogFormatter } from '../formatter/index.js'
-import { LogEntry } from '../types.js'
-import { toInspectLogEntry } from './toInspectStringForObject.js'
-
-export function logEntriesToString(logs: LogEntry[]) {
-  return logs.map(toInspectLogEntry).map(plainLogFormatter).join('\n')
-}

package/ts/memory/toInspectStringForObject.ts

@@ -1,13 +0,0 @@
-import isNode from 'is-node'
-import { LogEntry } from '../LogEntry.js'
-
-export const toInspectLogEntry = isNode
-  ? (() => {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const inspect = require('util').inspect
-    return (e: LogEntry) => (
-      e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),
-      e)
-  })()
-  // istanbul ignore next
-  : (e: LogEntry) => e

package/ts/shouldLog.ts

@@ -1,11 +0,0 @@
-import { store } from './store.js'
-import { LogLevel } from './types.js'
-
-/**
- * Determines should you log.
- * @param loggerLevel Log level of the logger.
- * It can be undefined which the global log level will be used.
- */
-export function shouldLog(targetLevel: LogLevel, loggerLevel: LogLevel | undefined) {
-  return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.value.logLevel)
-}