standard-log 8.0.1 → 9.1.0

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', 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', 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,72 +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',
-        Object.getOwnPropertyDescriptor(this, 'formatter')!.set!
-      )
-      formatter = value
-    },
-    get filter() {
-      return filter
-    },
-    set filter(value: LogFilter) {
-      assertLogModeIsNotProduction(
-        'set Reporter.filter',
-        Object.getOwnPropertyDescriptor(this, 'filter')!.set!
-      )
-      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)
-}

package/ts/store.ts

@@ -1,25 +0,0 @@
-import { createStore } from 'global-store'
-import { getLogModeFromEnvironment } from './getLogModeFromEnvironment.js'
-import { logLevels } from './logLevel.js'
-import { LogStore } from './typesInternal.js'
-
-export const store = createStore<LogStore>({
-  moduleName: 'standard-log',
-  key: 'e53d0937-f420-40a0-9901-099725fa4a53',
-  version: '2.0.0',
-  initializer: (current) => {
-    const mode = getLogModeFromEnvironment() || 'production'
-    return {
-      addCustomLogLevelListeners: [],
-      configured: false,
-      loggerClosures: {},
-      redirects: {},
-      reporters: [],
-      customLevels: {},
-      customLevelsReverse: [],
-      mode,
-      logLevel: logLevels.info,
-      ...current
-    }
-  }
-})

package/ts/suppressLogs.ts

@@ -1,14 +0,0 @@
-import { logLevels } from './logLevel.js'
-import { Logger } from './types.js'
-
-/**
- * Suppress logging within the code block.
- */
-export function suppressLogs<R>(block: () => R, log: Logger, ...logs: Logger[]): R
-export function suppressLogs<R>(block: () => R, ...logs: Logger[]): R {
-  const origLevels = logs.map(l => l.level)
-  logs.forEach(l => l.level = logLevels.none)
-  const result = block()
-  logs.forEach((l, i) => l.level = origLevels[i])
-  return result
-}

package/ts/typesInternal.ts

@@ -1,21 +0,0 @@
-import { Logger, LogLevel, LogLevelListener, LogMode, LogReporter } from './types.js'
-
-export type LoggerClosure<T extends string> = {
-  addMethod(name: string, level: number): void,
-  logger: Logger<T>
-}
-
-export type LogStore = {
-  mode: LogMode,
-  logLevel: LogLevel,
-  loggerClosures: Record<string, LoggerClosure<any>>,
-  /**
-   * redirects logger to specific reporter.
-   */
-  redirects: Record<string, LogReporter[]>,
-  reporters: LogReporter[],
-  customLevels: Record<string, number>,
-  customLevelsReverse: string[],
-  addCustomLogLevelListeners: LogLevelListener[],
-  configured: boolean
-}

package/ts/utils.ts

@@ -1,11 +0,0 @@
-import { AnyFunction } from 'type-plus'
-import { ProhibitedDuringProduction } from './errors.js'
-import { store } from './store.js'
-
-/**
- * Helper function to assert the system is not in production mode.
- */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function assertLogModeIsNotProduction(action: string, ssf: AnyFunction) {
-  if (store.value.mode === 'production') throw new ProhibitedDuringProduction(action, { ssf })
-}

package/ts/writeToReporters.ts

@@ -1,20 +0,0 @@
-import { config } from './config.js'
-import { store } from './store.js'
-import { LogEntry } from './types.js'
-
-export function writeToReporters(logEntry: LogEntry, filter: (reporterId: string) => boolean) {
-  writeToReporters.fn(logEntry, filter)
-}
-
-// istanbul ignore next
-writeToReporters.fn = (logEntry: LogEntry, filter: (reporterId: string) => boolean) => {
-  const store = getConfiguredStore()
-  const redirect = store.value.redirects[logEntry.id]
-  const reporters = redirect && redirect.length > 0 ? redirect : store.value.reporters
-  reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
-}
-
-function getConfiguredStore() {
-  if (!store.value.configured) config()
-  return store
-}