standard-log 7.0.3 → 8.0.1

package/src/console/createConsoleLogReporter.spec.ts

@@ -1,198 +0,0 @@
-import a from 'assertron'
-import {
-  addCustomLogLevel, clearCustomLogLevel, config, configForTest,
-  ConsoleLogFormatter, createConsoleLogReporter,
-  LogFilter, logLevels, plainLogFormatter, ProhibitedDuringProduction
-} from '..'
-import { store } from '../store'
-
-describe('production checks', () => {
-  beforeEach(() => store.reset())
-
-  test('set filter during production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createConsoleLogReporter()
-    a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
-  })
-
-  const idFormatter: ConsoleLogFormatter = (entry) => [entry.id]
-  test('set formatter during production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createConsoleLogReporter()
-    a.throws(() => reporter.formatter = idFormatter, ProhibitedDuringProduction)
-  })
-})
-
-
-describe('unit tests', () => {
-  beforeEach(() => configForTest())
-
-  describe('rendering tests', () => {
-    test('plain rendering', () => {
-      const reporter = createConsoleLogReporter({ formatter: plainLogFormatter });
-      ['emergency', 'info', 'warn', 'debug'].forEach(level => {
-        reporter.write({ id: 'plain', level: (logLevels as any)[level], args: ['hello', 'world'], timestamp: new Date() })
-      })
-    })
-  })
-
-  describe('id', () => {
-    test('default is "console"', () => {
-      const reporter = createConsoleLogReporter()
-      expect(reporter.id).toBe('console')
-    })
-    test('can be overridden', () => {
-      const reporter = createConsoleLogReporter({ id: 'neo-console' })
-      expect(reporter.id).toBe('neo-console')
-    })
-  })
-
-  describe('log level', () => {
-    test('error, alert, critical and emergency logs are written to console.error', () => {
-      const id = 'log'
-      const reporter = createConsoleLogReporter()
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.critical, args: ['critical'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.alert, args: ['alert'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.error, args: ['error'], timestamp: new Date() })
-
-      expect(fakeConsole.errors.length).toBe(4)
-    })
-
-    test('warn logs are written to console.warn', () => {
-      const id = 'log'
-      const reporter = createConsoleLogReporter()
-
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: logLevels.warn, args: ['warn'], timestamp: new Date() })
-
-      expect(fakeConsole.warns.length).toBe(1)
-    })
-
-    test('notice and info logs are written to console.info', () => {
-      const id = 'log'
-      const reporter = createConsoleLogReporter()
-
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: logLevels.notice, args: ['notice'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.info, args: ['info'], timestamp: new Date() })
-
-      expect(fakeConsole.infos.length).toBe(2)
-    })
-
-
-    test('debug, trace, and planck logs are written to console.debug', () => {
-      const id = 'log'
-      const reporter = createConsoleLogReporter()
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: logLevels.debug, args: ['debug'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.trace, args: ['trace'], timestamp: new Date() })
-      reporter.write({ id, level: logLevels.planck, args: ['planck'], timestamp: new Date() })
-
-      expect(fakeConsole.debugs.length).toBe(3)
-    })
-  })
-
-  describe('custom logs', () => {
-    afterEach(() => clearCustomLogLevel())
-
-    test('are written according to their log level value', () => {
-      addCustomLogLevel('high', 50)
-      addCustomLogLevel('important', 450)
-      addCustomLogLevel('interest', 650)
-      addCustomLogLevel('silly', 1000)
-
-      const id = 'log'
-      const reporter = createConsoleLogReporter()
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: 50, args: ['a'], timestamp: new Date() })
-      reporter.write({ id, level: 450, args: ['b'], timestamp: new Date() })
-      reporter.write({ id, level: 650, args: ['c'], timestamp: new Date() })
-      reporter.write({ id, level: 1000, args: ['d'], timestamp: new Date() })
-
-      expect(fakeConsole.errors.length).toBe(1)
-      expect(fakeConsole.warns.length).toBe(1)
-      expect(fakeConsole.infos.length).toBe(1)
-      expect(fakeConsole.debugs.length).toBe(1)
-    })
-  })
-
-  const idFormatter: ConsoleLogFormatter = (entry) => [entry.id]
-
-  describe('formatter', () => {
-    test('use specific formatter', () => {
-      const id = 'id-only'
-      const reporter = createConsoleLogReporter({ formatter: idFormatter })
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-
-      expect(fakeConsole.errors).toEqual([['id-only']])
-    })
-
-    test('formatter can be changed afterward', () => {
-      const reporter = createConsoleLogReporter()
-      const formatter = reporter.formatter
-      reporter.formatter = idFormatter
-      expect(reporter.formatter).not.toEqual(formatter)
-    })
-  })
-
-  describe('filter', () => {
-    const filter: LogFilter = (entry) => entry.id !== 'secret'
-    test('use specific filter', () => {
-      const reporter = createConsoleLogReporter({ formatter: idFormatter, filter })
-      const fakeConsole = reporter.console = createFakeConsole()
-
-      reporter.write({ id: 'normal', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-      reporter.write({ id: 'secret', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-
-      expect(fakeConsole.errors).toEqual([['normal']])
-    })
-
-    test('can change filter', () => {
-      const reporter = createConsoleLogReporter()
-      const filter = reporter.filter
-      reporter.filter = entry => entry.id !== 'secret'
-      expect(reporter.filter).not.toEqual(filter)
-    })
-  })
-
-  test('write log entry with multiple arguments', () => {
-    const id = 'log'
-    const reporter = createConsoleLogReporter({ formatter: plainLogFormatter })
-    const fakeConsole = reporter.console = createFakeConsole()
-
-    const entry = { id, level: logLevels.info, args: ['a', 'b', 'c'], timestamp: new Date() }
-
-    reporter.write(entry)
-
-    expect(fakeConsole.infos).toEqual([
-      [entry.timestamp.toISOString(), 'log', '(INFO)', 'a', 'b', 'c']
-    ])
-  })
-})
-
-
-function createFakeConsole() {
-  const errors: any[] = []
-  const infos: any[] = []
-  const warns: any[] = []
-  const debugs: any[] = []
-  return {
-    errors,
-    infos,
-    warns,
-    debugs,
-    error(...args: any[]) { errors.push(args) },
-    info(...args: any[]) { infos.push(args) },
-    warn(...args: any[]) { warns.push(args) },
-    debug(...args: any[]) { debugs.push(args) }
-  }
-}

package/src/console/createConsoleLogReporter.ts

@@ -1,42 +0,0 @@
-import { required } from 'type-plus'
-import { plainLogFormatter } from '../formatter'
-import { LogFormatter, LogReporter, LogReporterOptions, LogFilter } from '../types'
-import { assertLogModeIsNotProduction } from '../utils'
-import { polyfilledConsole } from './polyfilledConsole'
-import { toConsoleMethod } from './toConsoleMethod'
-import { Console } from './types'
-
-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/src/console/index.ts

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

package/src/console/isConsoleDebugAvailable.ts

@@ -1,11 +0,0 @@
-import isNode from 'is-node'
-import { semverGt } from './semverGt'
-
-// 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/src/console/polyfilledConsole.ts

@@ -1,34 +0,0 @@
-/* istanbul ignore file */
-import { isConsoleDebugAvailable } from './isConsoleDebugAvailable'
-/* 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/src/console/semverGt.spec.ts

@@ -1,25 +0,0 @@
-import { semverGt } from './semverGt';
-
-test('9.3.0 returns false', () => {
-  expect(semverGt('9.3.0', [9, 3, 0])).toBe(false)
-})
-
-test('9.3.1 returns true', () => {
-  expect(semverGt('9.3.1', [9, 3, 0])).toBe(true)
-})
-
-test('9.3.1 returns true', () => {
-  expect(semverGt('9.3.1', [9, 3, 0])).toBe(true)
-})
-
-test('9.4.0 returns true', () => {
-  expect(semverGt('9.4.0', [9, 3, 0])).toBe(true)
-})
-
-test('9.10.0 returns true', () => {
-  expect(semverGt('9.10.0', [9, 3, 0])).toBe(true)
-})
-
-test('10.0.0 returns true', () => {
-  expect(semverGt('10.0.0', [9, 3, 0])).toBe(true)
-})

package/src/console/toConsoleMethod.ts

@@ -1,18 +0,0 @@
-import { logLevels } from '../logLevel';
-
-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/src/console/types.ts

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

package/src/customLogLevel.spec.ts

@@ -1,39 +0,0 @@
-import a from 'assertron';
-import { addCustomLogLevel, clearCustomLogLevel, getCustomLevels, getLogger, logLevels } from '.';
-import { config } from './config';
-import { createMemoryLogReporter } from './memory';
-import { store } from './store';
-
-afterEach(() => store.reset())
-
-describe('clearCustomLogLevel()', () => {
-  test('clear all custom levels', () => {
-    addCustomLogLevel('c1', logLevels.none + 1)
-    addCustomLogLevel('c2', logLevels.none + 2)
-    expect(getCustomLevels().length).toBe(2)
-
-    clearCustomLogLevel()
-
-    expect(getCustomLevels().length).toBe(0)
-  })
-})
-
-test('custom level will not write if log level is lower', () => {
-  const memReporter = createMemoryLogReporter()
-  config({
-    mode: 'test',
-    reporters: [memReporter]
-  })
-
-  addCustomLogLevel('c1', logLevels.debug + 1)
-  const log = getLogger<'c1'>('custom-level-not-write')
-  log.c1('will not write this')
-
-  expect(memReporter.logs.length).toEqual(0)
-})
-
-test('custom level method is readonly', () => {
-  addCustomLogLevel('c1', logLevels.debug + 1)
-  const log = getLogger<'c1'>('custom method readonly')
-  a.throws(() => { log.c1 = () => {} })
-})

package/src/customLogLevel.ts

@@ -1,35 +0,0 @@
-import { forEachKey, mapKey } from 'type-plus';
-import { store } from './store';
-import { LogLevelEntry } from './types';
-
-/**
- * @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/src/errors.ts

@@ -1,24 +0,0 @@
-import { IsoError, ModuleError } from 'iso-error'
-
-export class StandardLogError extends ModuleError {
-  constructor(description: string, options?: IsoError.Options) {
-    super('standard-log', description, options)
-  }
-}
-export class InvalidId extends StandardLogError {
-  constructor(public id: string) {
-    super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`)
-  }
-}
-
-export class ProhibitedDuringProduction extends StandardLogError {
-  constructor(public action: string) {
-    super(`Cannot perform ${action} during production`)
-  }
-}
-
-export class InvalidEnvVar extends StandardLogError {
-  constructor(public name: string, public value: string, public possibleValues: string[]) {
-    super(`${name} contains invalid value '${value}'${` valid values: [${possibleValues.join()}]`}`)
-  }
-}

package/src/formatter/createTimestampFormatter.spec.ts

@@ -1,24 +0,0 @@
-import { createTimestampFormatter } from '..'
-
-test('none', () => {
-  const formatter = createTimestampFormatter('none')
-  const now = new Date()
-  const actual = [formatter(now)]
-  expect(actual).toEqual([undefined])
-})
-
-test('iso', () => {
-  const formatter = createTimestampFormatter('iso')
-  const now = new Date()
-  const actual = [formatter(now)]
-  expect(actual).toEqual([now.toISOString()])
-})
-
-test('elapsed', () => {
-  const formatter = createTimestampFormatter('elapsed')
-  const now = new Date()
-  const next = new Date(now.getTime() + 10)
-  const actual = [formatter(now), formatter(next)]
-
-  expect(actual).toEqual(['0ms', '10ms'])
-})

package/src/formatter/createTimestampFormatter.ts

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

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

package/src/formatter/index.ts

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

package/src/formatter/plainLogFormatter.spec.ts

@@ -1,8 +0,0 @@
-import { logLevels, plainLogFormatter } from '..';
-
-test('convert log entries to string', () => {
-  const timestamp = new Date(2019, 6)
-  const actual = plainLogFormatter({ id: 'plain', level: logLevels.emergency, args: ['emergency'], timestamp })
-
-  expect(actual).toEqual([timestamp.toISOString(), 'plain', `(EMERGENCY)`, `emergency`])
-})

package/src/formatter/plainLogFormatter.ts

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

package/src/getDefaultReporter.browser.ts

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

package/src/getDefaultReporter.ts

@@ -1,15 +0,0 @@
-import { createConsoleLogReporter } from './console';
-
-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/src/getLogModeFromEnvironment.browser.ts

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

package/src/getLogModeFromEnvironment.spec.ts

@@ -1,16 +0,0 @@
-import a from 'assertron';
-import { InvalidEnvVar } from '.';
-import { getLogModeFromEnvironment } from './getLogModeFromEnvironment';
-
-test('invalid value throws', () => {
-  process.env.STANDARD_LOG = 'unknown'
-  a.throws(() => getLogModeFromEnvironment(), InvalidEnvVar)
-})
-
-test('valid values', () => {
-  process.env.STANDARD_LOG = 'production'
-  expect(getLogModeFromEnvironment()).toBe('production')
-
-  process.env.STANDARD_LOG = 'development'
-  expect(getLogModeFromEnvironment()).toBe('development')
-})

package/src/getLogModeFromEnvironment.ts

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