standard-log 11.0.1 → 11.1.0

package/ts/memory.ts

@@ -1,4 +1,4 @@
-import { required } from 'type-plus'
+import { required, unpartial } from 'type-plus'
 import { toInspectLogEntry } from './platform.js'
 import { formatLogLevel } from './formatter.js'
 import type { LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './types.js'
@@ -30,9 +30,13 @@ export function toMessageWithLevel(logs: LogEntry[]) {
 }
 
 export function createMemoryLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
+  return Object.freeze(buildMemoryReporter(unpartial({ id: 'memory' }, options)))
+}
+
+function buildMemoryReporter(options?: LogReporterOptions<LogEntry>) {
   const { id, formatter, filter } = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
   const logs: LogEntry[] = []
-  return Object.freeze({
+  return {
     id,
     get formatter() { return formatter },
     get filter() { return filter },
@@ -60,5 +64,12 @@ export function createMemoryLogReporter(options?: LogReporterOptions<LogEntry>):
       const reporter = createConsoleLogReporter()
       logs.forEach(l => reporter.write(l))
     }
-  })
+  }
+}
+
+export function createMemoryWithConsoleLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
+  return Object.freeze(
+    Object.assign(buildMemoryReporter(unpartial({ id: 'memory-with-console' }, options)), {
+      isConsoleReporter: true
+    }))
 }

package/ts/platform.browser.ts

@@ -1,5 +1,6 @@
+import { record } from 'type-plus'
 import type { ConsoleLike, LogEntry } from './types.js'
 
 export const toInspectLogEntry = (e: LogEntry) => e
 
-export const polyfill: { console?: ConsoleLike } = {}
+export const polyfill: { console?: ConsoleLike } = record()

package/ts/platform.ts

@@ -1,3 +1,4 @@
+import { record } from 'type-plus'
 import { inspect } from 'util'
 import type { ConsoleLike, LogEntry } from './types.js'
 
@@ -5,4 +6,4 @@ export const toInspectLogEntry = (e: LogEntry) => (
   e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),
   e)
 
-export const polyfill: { console?: ConsoleLike } = {}
+export const polyfill: { console?: ConsoleLike } = record()

package/ts/standardLog.ts

@@ -1,6 +1,6 @@
 import { record, required } from 'type-plus'
 import { createLogger } from './logger.js'
-import { logLevels } from './logLevels.js'
+import { DEFAULT_LOG_METHOD_NAMES, logLevels } from './logLevels.js'
 import { createLogStore, LogStore } from './logStore.js'
 import { createMemoryLogReporter, MemoryLogReporter } from './memory.js'
 import type { Logger, LoggerOptions, LogLevel, LogMethodNames, StandardLogOptions } from './types.js'
@@ -9,7 +9,8 @@ export interface StandardLogInstance<N extends string = LogMethodNames> {
   logLevel: number,
   toLogLevelName(level: number): string,
   toLogLevel(name: N): number,
-  getLogger(id: string, options?: LoggerOptions): Logger<N | LogMethodNames>
+  getLogger(id: string, options?: LoggerOptions): Logger<N | LogMethodNames>,
+  getNonConsoleLogger(id: string, options?: LoggerOptions): Logger<N | LogMethodNames>
 }
 
 export interface StandardLog<N extends string = LogMethodNames> extends Readonly<StandardLogInstance<N>> {
@@ -19,15 +20,26 @@ export function createStandardLog<N extends string = LogMethodNames>(
   options?: StandardLogOptions<N>
 ): StandardLog<N> {
   const closure = createStandardLogClosure(options)
+  if (options?.reporters?.some(r => !r.id)) {
+    const log = closure.standardLog.getLogger('standard-log')
+    log.critical(`Detected reporter with empty id. This is not allowed as it will create problems with feature like 'getNonConsoleLogger()'. Please add an id to your reporter.`)
+  }
+
   if (!ctx.gsl) ctx.gsl = closure as any
   return closure.standardLog
 }
 
+function noop() { }
+
 export function createStandardLogClosure<N extends string = LogMethodNames>(
   options?: StandardLogOptions<N>
 ): { store: LogStore, standardLog: StandardLog<N> } {
+  // TODO reporter.id must not be empty
   const store = createLogStore(required({ logLevel: logLevels.info }, options))
-
+  const nonConsoleReporters = options?.reporters?.filter(r => !r.isConsoleReporter).map(r => r.id) ?? []
+  const logMethods = DEFAULT_LOG_METHOD_NAMES
+    .concat(Object.keys(options?.customLevels ?? {}))
+    .concat(['on', 'count', 'write'])
   return {
     store,
     standardLog: {
@@ -42,19 +54,45 @@ export function createStandardLogClosure<N extends string = LogMethodNames>(
       getLogger(id: string, options?: LoggerOptions) {
         if (store.loggers[id]) return store.loggers[id] as any
         return store.loggers[id] = createLogger(store, id, { ssf: this.getLogger, ...options }) as any
-      }
+      },
+      getNonConsoleLogger(id, options?) {
+        if (store.nonConsoleLoggers[id]) return store.nonConsoleLoggers[id] as any
+
+        if (store.loggers[id]) {
+          const log = this.getLogger('standard-log')
+          log.warn(`attempt to create a non-console logger with existing id ('${id}'), ignoring`)
+          return store.nonConsoleLoggers[id] = createDummyLogger(logMethods)
+        }
+
+        return store.nonConsoleLoggers[id] = nonConsoleReporters.length === 0
+          ? createDummyLogger(logMethods)
+          : createLogger(store, id, {
+            ssf: this.getNonConsoleLogger,
+            ...options,
+            writeTo(reporterId) {
+              return nonConsoleReporters.indexOf(reporterId) >= 0
+            }
+          })
+      },
     }
   }
 }
 
+function createDummyLogger(logMethods: string[]) {
+  return logMethods.reduce((p, m) => {
+    p[m] = noop
+    return p
+  }, record()) as Logger
+}
+
 export type StandardLogForTest<N extends string = LogMethodNames> = StandardLog<N> & { reporter: MemoryLogReporter }
 
 export function createStandardLogForTest<N extends string = LogMethodNames>(
   logLevel: LogLevel = logLevels.debug
 ): StandardLogForTest<N> {
   const reporter = createMemoryLogReporter()
-  const standardLog = createStandardLog<N>({ reporters: [reporter], logLevel })
-  return { ...standardLog, reporter }
+  const closure = createStandardLogClosure<N>({ reporters: [reporter], logLevel })
+  return { ...closure.standardLog, reporter }
 }
 
 /**
@@ -86,8 +124,8 @@ function getGlobalSL<N extends string = LogMethodNames>(): StandardLogInstance<N
 
 export function configGlobal(options: Omit<StandardLogOptions, 'customLevels'>) {
   if (ctx.configured) {
-    const log = ctx.gsl?.standardLog.getLogger('standard-log')
-    log?.warn('configGlobal() is being called more than once. Please make sure this is expected. Application should use `createStandardLog()` most of the time.')
+    const log = ctx.gsl!.standardLog.getLogger('standard-log')
+    log.warn('configGlobal() is being called more than once. Please make sure this is expected. Application should use `createStandardLog()` most of the time.')
   }
 
   if (ctx.gsl) {