standard-log 8.0.1 → 9.0.0

package/esm/types.d.ts

@@ -1,13 +1,12 @@
-export declare type LogMode = 'development' | 'production' | 'test';
-export declare type LogMethodNames = 'emergency' | 'alert' | 'critical' | 'error' | 'warn' | 'notice' | 'info' | 'debug' | 'trace' | 'planck';
-export declare type LogMethod = (...args: any[]) => void;
-export declare type LogFunction = ((log: LogMethod) => void) | (() => string);
-export declare type LogEntry = {
-    id: string;
-    level: number;
-    args: any[];
-    timestamp: Date;
+export declare type StandardLogOptions<CustomLevelNames extends string = string> = {
+    customLevels: Record<CustomLevelNames, number>;
+    logLevel: number;
+    reporters: LogReporter[];
 };
+export interface LoggerOptions {
+    level?: number;
+    writeTo?: LogReporter | ReporterFilter;
+}
 export declare type Logger<T extends string = LogMethodNames> = {
     readonly id: string;
     /**
@@ -22,17 +21,28 @@ export declare type Logger<T extends string = LogMethodNames> = {
     on(level: number | T, logFunction: LogFunction): void;
     /**
      * Write custom log entries.
-     * This can be used along with `captureLogs()` to rewrite the logs at a later time.
      */
     write(entry: LogEntry): void;
 } & {
     [k in T]: LogMethod;
 };
+/**
+ * Names of the standard log methods.
+ */
+export declare type LogMethodNames = 'emergency' | 'alert' | 'critical' | 'error' | 'warn' | 'notice' | 'info' | 'debug' | 'trace' | 'planck';
+export declare type LogEntry = {
+    id: string;
+    level: number;
+    args: any[];
+    timestamp: Date;
+};
+export declare type LogMethod = (...args: any[]) => void;
+export declare type LogFunction = ((log: LogMethod) => void) | (() => string);
 export declare type ReporterFilter = string | RegExp | ((reporterId: string) => boolean);
 /**
  * Formats a log entry.
  * Depends on the reporter, it can expect a different return type.
- * By default the return type is `any[]` which `console` accepts.
+ * By default the return type is `any[]` which the `console` accepts.
  */
 export declare type LogFormatter<T = any[]> = (entry: LogEntry) => T;
 /**
@@ -43,31 +53,24 @@ export declare type LogLevelEntry = {
     name: string;
     level: number;
 };
-export declare type LogLevelListener = (logLevelEntry: LogLevelEntry) => void;
-export declare type LogReporter<T = any> = {
-    id: string;
+export interface LogReporter<T = any> {
+    readonly id: string;
     /**
      * Specifies the formatter to be used by the reporter.
      * Using this you can customize how the reporter writes the log entry.
-     * This is readonly in production mode.
      */
-    formatter: LogFormatter<T>;
+    readonly formatter: LogFormatter<T>;
     /**
      * Specifies a filter to determine should the log be written.
-     * This is readonly in production mode.
      */
-    filter?: LogFilter;
+    readonly filter?: LogFilter;
     /**
      * Indicate if this is a console reporter.
      * There is only one console reporter can be present in the system.
-     * If a new console reporter is added,
-     * it will be used in place of the existing one.
-     * However, existing filter will be carried over to ensure logs should not be shown remain not shown.
-     * If the new reporter also contains a filter, they will be combined.
      */
-    isConsoleReporter?: boolean;
+    readonly isConsoleReporter?: boolean;
     write(entry: LogEntry): void;
-};
+}
 export declare type LogReporterOptions<T = any> = {
     id?: string;
     /**
@@ -81,4 +84,10 @@ export declare type LogReporterOptions<T = any> = {
     filter?: LogFilter;
 };
 export declare type LogLevel = number;
+export interface ConsoleLike {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
 //# sourceMappingURL=types.d.ts.map

package/esm/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../ts/types.ts"],"names":[],"mappings":"AACA,oBAAY,OAAO,GAAG,aAAa,GAAG,YAAY,GAAG,MAAM,CAAA;AAE3D,oBAAY,cAAc,GAAG,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;AACrI,oBAAY,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;AAChD,oBAAY,WAAW,GAAG,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;AAErE,oBAAY,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,SAAS,EAAE,IAAI,CAAA;CAChB,CAAA;AAED,oBAAY,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,cAAc,IAAI;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5B,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IACtD;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;CAC7B,GAAG;KACC,CAAC,IAAI,CAAC,GAAG,SAAS;CACpB,CAAA;AAEH,oBAAY,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAA;AAEhF;;;;GAIG;AACH,oBAAY,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,KAAK,CAAC,CAAA;AAE5D;;GAEG;AACH,oBAAY,SAAS,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAA;AAEpD,oBAAY,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D,oBAAY,gBAAgB,GAAG,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;AAErE,oBAAY,WAAW,CAAC,CAAC,GAAG,GAAG,IAAI;IACjC,EAAE,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;CAC7B,CAAA;AAED,oBAAY,kBAAkB,CAAC,CAAC,GAAG,GAAG,IAAI;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,SAAS,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC5B;;OAEG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB,CAAA;AAED,oBAAY,QAAQ,GAAG,MAAM,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../ts/types.ts"],"names":[],"mappings":"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"}

package/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../ts/types.ts"],"names":[],"mappings":"","sourcesContent":["\nexport type LogMode = 'development' | 'production' | 'test'\n\nexport type LogMethodNames = 'emergency' | 'alert' | 'critical' | 'error' | 'warn' | 'notice' | 'info' | 'debug' | 'trace' | 'planck'\nexport type LogMethod = (...args: any[]) => void\nexport type LogFunction = ((log: LogMethod) => void) | (() => string)\n\nexport type LogEntry = {\n  id: string,\n  level: number,\n  // args instead of messages because it is `any[]` instead of `string[]`\n  args: any[],\n  timestamp: Date\n}\n\nexport type Logger<T extends string = LogMethodNames> = {\n  readonly id: string,\n  /**\n   * Logger local log level.\n   */\n  level?: number,\n  /**\n   * Logs with an increment counter.\n   * This is useful during debugging to check for steps executed.\n   */\n  count(...args: any[]): void,\n  on(level: number | T, logFunction: LogFunction): void,\n  /**\n   * Write custom log entries.\n   * This can be used along with `captureLogs()` to rewrite the logs at a later time.\n   */\n  write(entry: LogEntry): void\n} & {\n    [k in T]: LogMethod\n  }\n\nexport type ReporterFilter = string | RegExp | ((reporterId: string) => boolean)\n\n/**\n * Formats a log entry.\n * Depends on the reporter, it can expect a different return type.\n * By default the return type is `any[]` which `console` accepts.\n */\nexport type LogFormatter<T = any[]> = (entry: LogEntry) => T\n\n/**\n * Determines whether the entry should be written.\n */\nexport type LogFilter = (entry: LogEntry) => boolean\n\nexport type LogLevelEntry = { name: string, level: number }\n\nexport type LogLevelListener = (logLevelEntry: LogLevelEntry) => void\n\nexport type LogReporter<T = any> = {\n  id: string,\n  /**\n   * Specifies the formatter to be used by the reporter.\n   * Using this you can customize how the reporter writes the log entry.\n   * This is readonly in production mode.\n   */\n  formatter: LogFormatter<T>,\n  /**\n   * Specifies a filter to determine should the log be written.\n   * This is readonly in production mode.\n   */\n  filter?: LogFilter,\n  /**\n   * Indicate if this is a console reporter.\n   * There is only one console reporter can be present in the system.\n   * If a new console reporter is added,\n   * it will be used in place of the existing one.\n   * However, existing filter will be carried over to ensure logs should not be shown remain not shown.\n   * If the new reporter also contains a filter, they will be combined.\n   */\n  isConsoleReporter?: boolean,\n  write(entry: LogEntry): void\n}\n\nexport type LogReporterOptions<T = any> = {\n  id?: string,\n  /**\n   * Specifies the formatter to be used by the reporter.\n   * Using this you can customize how the reporter writes the log entry.\n   */\n  formatter?: LogFormatter<T>,\n  /**\n   * Specifies a filter to determine should the log be written.\n   */\n  filter?: LogFilter\n}\n\nexport type LogLevel = number\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../ts/types.ts"],"names":[],"mappings":"","sourcesContent":["export type StandardLogOptions<CustomLevelNames extends string = string> = {\n  customLevels: Record<CustomLevelNames, number>,\n  logLevel: number,\n  reporters: LogReporter[]\n}\n\nexport interface LoggerOptions {\n  level?: number,\n  writeTo?: LogReporter | ReporterFilter\n}\n\nexport type Logger<T extends string = LogMethodNames> = {\n  readonly id: string,\n  /**\n   * Logger local log level.\n   */\n  level?: number,\n  /**\n   * Logs with an increment counter.\n   * This is useful during debugging to check for steps executed.\n   */\n  count(...args: any[]): void,\n  on(level: number | T, logFunction: LogFunction): void,\n  /**\n   * Write custom log entries.\n   */\n  write(entry: LogEntry): void\n} & { [k in T]: LogMethod }\n\n/**\n * Names of the standard log methods.\n */\nexport type LogMethodNames = 'emergency' | 'alert' | 'critical' | 'error' | 'warn' | 'notice' | 'info' | 'debug' | 'trace' | 'planck'\n\nexport type LogEntry = {\n  id: string,\n  level: number,\n  // args instead of messages because it is `any[]` instead of `string[]`\n  args: any[],\n  timestamp: Date\n}\n\nexport type LogMethod = (...args: any[]) => void\n\nexport type LogFunction = ((log: LogMethod) => void) | (() => string)\n\nexport type ReporterFilter = string | RegExp | ((reporterId: string) => boolean)\n\n/**\n * Formats a log entry.\n * Depends on the reporter, it can expect a different return type.\n * By default the return type is `any[]` which the `console` accepts.\n */\nexport type LogFormatter<T = any[]> = (entry: LogEntry) => T\n\n/**\n * Determines whether the entry should be written.\n */\nexport type LogFilter = (entry: LogEntry) => boolean\n\nexport type LogLevelEntry = { name: string, level: number }\n\nexport interface LogReporter<T = any> {\n  readonly id: string,\n  /**\n   * Specifies the formatter to be used by the reporter.\n   * Using this you can customize how the reporter writes the log entry.\n   */\n  readonly formatter: LogFormatter<T>,\n  /**\n   * Specifies a filter to determine should the log be written.\n   */\n  readonly filter?: LogFilter,\n  /**\n   * Indicate if this is a console reporter.\n   * There is only one console reporter can be present in the system.\n   */\n  readonly isConsoleReporter?: boolean,\n  write(entry: LogEntry): void\n}\n\nexport type LogReporterOptions<T = any> = {\n  id?: string,\n  /**\n   * Specifies the formatter to be used by the reporter.\n   * Using this you can customize how the reporter writes the log entry.\n   */\n  formatter?: LogFormatter<T>,\n  /**\n   * Specifies a filter to determine should the log be written.\n   */\n  filter?: LogFilter\n}\n\nexport type LogLevel = number\n\nexport interface ConsoleLike {\n  debug(...args: any[]): void,\n  info(...args: any[]): void,\n  warn(...args: any[]): void,\n  error(...args: any[]): void,\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standard-log",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "The standard log library",
   "homepage": "https://github.com/unional/standard-log/tree/master/packages/log",
   "bugs": {
@@ -23,12 +23,9 @@
   },
   "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"
+    "./cjs/platform.js": "./cjs/platform.browser.js",
+    "./esm/platform.js": "./esm/platform.browser.js",
+    "./ts/platform.js": "./ts/platform.browser.js"
   },
   "typings": "./cjs/index.d.ts",
   "files": [
@@ -48,7 +45,7 @@
     "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",
+    "clean": "rimraf cjs coverage dist esm lib libm tslib .tsbuildinfo && mkdir cjs && echo '{\"type\":\"commonjs\"}' > cjs/package.json || true",
     "coverage": "jest --coverage",
     "depcheck": "depcheck",
     "lint": "cross-env TIMING=1 eslint --ext=ts,js,cjs,mjs .",
@@ -58,42 +55,36 @@
     "watch": "jest --watch"
   },
   "dependencies": {
-    "is-node": "^1.0.2",
-    "iso-error": "^4.3.3",
+    "@just-func/types": "^0.2.0",
+    "iso-error": "^4.3.5",
     "ms": "^2.1.3",
-    "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",
+    "@types/ramda": "^0.28.13",
     "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",
+    "ramda": "^0.28.0",
     "rimraf": "^3.0.2",
     "size-limit": "^7.0.8",
     "ts-jest": "^28.0.4",
     "ts-loader": "^9.3.0",
+    "tslib": "^2.4.0",
     "typescript": "^4.7.3",
     "webpack": "^5.73.0",
     "webpack-bundle-analyzer": "^4.5.0",
     "webpack-cli": "^4.9.2"
   },
-  "peerDependencies": {
-    "global-store": "*"
-  },
-  "optionalDependencies": {
-    "ramda": "^0.28.0"
-  },
   "size-limit": [
     {
       "path": "./cjs/index.js",

package/ts/console.ts

@@ -0,0 +1,72 @@
+import { required } from 'type-plus'
+import { logLevels } from './logLevels.js'
+import { isConsoleDebugAvailable, polyfill } from './platform.js'
+import { plainLogFormatter } from './formatter.js'
+import type { ConsoleLike, LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './types.js'
+
+export function toConsoleMethod(level: number) {
+  switch (true) {
+    // edge case in case none is somehow written
+    case (level <= 0): return 'debug'
+    case (level <= logLevels.error): return 'error'
+    case (level <= logLevels.warn): return 'warn'
+    case (level <= logLevels.info): return 'info'
+    default: return 'debug'
+  }
+}
+
+// istanbul ignore next
+/* 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'),
+    }
+  }
+}
+
+// istanbul ignore next
+function buildFn(name: 'debug' | 'info' | 'warn' | 'error' | 'log') {
+  return function (...args: any[]) { console[name](...args) }
+}
+
+
+export type ConsoleLogFormatter = LogFormatter<any[]>
+export type ConsoleLogReporter = LogReporter<any[]> & { console: ConsoleLike }
+export type ConsoleLogReporterOptions = LogReporterOptions<any[]>
+
+export function createConsoleLogReporter(options?: ConsoleLogReporterOptions): ConsoleLogReporter {
+  const { id, formatter, filter } = required({ id: 'console', formatter: plainLogFormatter }, options)
+  if (!polyfill.console) polyfill.console = buildPolyfillConsole()
+
+  return Object.freeze({
+    id,
+    isConsoleReporter: true,
+    get formatter() { return formatter },
+    get filter() { return filter },
+    console: polyfill.console,
+    write(entry: LogEntry) {
+      if (filter && !filter(entry)) return
+      const values = formatter(entry)
+      const method = toConsoleMethod(entry.level)
+      this.console[method](...values)
+    }
+  })
+}

package/ts/errors.ts

@@ -10,15 +10,3 @@ export class InvalidId extends StandardLogError {
     super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options)
   }
 }
-
-export class ProhibitedDuringProduction extends StandardLogError {
-  constructor(public action: string, options?: IsoError.Options) {
-    super(`Cannot perform ${action} during production`, options)
-  }
-}
-
-export class InvalidEnvVar extends StandardLogError {
-  constructor(public name: string, public value: string, public possibleValues: string[], options?: IsoError.Options) {
-    super(`${name} contains invalid value '${value}'${` valid values: [${possibleValues.join()}]`}`, options)
-  }
-}

package/ts/{formatter/createTimestampFormatter.ts → formatter.ts}

@@ -1,4 +1,7 @@
 import ms from 'ms'
+import { upperCase } from 'upper-case'
+import { toLogLevelName } from './logLevels.js'
+import type { LogEntry } from './types.js'
 
 export type TimestampFormat = 'none' | 'iso' | 'elapsed'
 
@@ -9,7 +12,7 @@ export function createTimestampFormatter(format: TimestampFormat) {
     case 'iso':
       return (timestamp: Date) => timestamp.toISOString()
     case 'elapsed': {
-      let lastTick: number | undefined = undefined
+      let lastTick: number
       return (timestamp: Date) => {
         const newTick = timestamp.getTime()
         const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
@@ -19,3 +22,11 @@ export function createTimestampFormatter(format: TimestampFormat) {
     }
   }
 }
+
+export function formatLogLevel(level: number) {
+  return `(${upperCase(toLogLevelName(level))})`
+}
+
+export function plainLogFormatter({ id, level, args, timestamp }: LogEntry) {
+  return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
+}

package/ts/index.ts

@@ -1,16 +1,7 @@
-export * from './captureLogs.js'
-export * from './config.js'
-export * from './configForTest.js'
-export * from './console/index.js'
-export * from './customLogLevel.js'
+export * from './console.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 './formatter.js'
+export * from './logLevels.js'
+export * from './memory.js'
+export * from './standardLog.js'
 export * from './types.js'
-export * from './utils.js'

package/ts/{logLevel.ts → logLevels.ts}

@@ -1,4 +1,3 @@
-
 export const logLevels = {
   /**
    * none: 0
@@ -52,6 +51,24 @@ export const logLevels = {
 }
 
 /**
- * @deprecated logLevel is renamed to logLevels
+ * Convert default log level value to log level name.
+ */
+export function toLogLevelName(level: number) {
+  if (level <= 100) return 'emergency'
+  if (level <= 200) return 'alert'
+  if (level <= 300) return 'critical'
+  if (level <= 400) return 'error'
+  if (level <= 500) return 'warn'
+  if (level <= 600) return 'notice'
+  if (level <= 700) return 'info'
+  if (level <= 800) return 'debug'
+  if (level <= 900) return 'trace'
+  return 'planck'
+}
+
+/**
+ * Convert default log level name to log level value.
  */
-export const logLevel = logLevels
+export function toLogLevel(name: string) {
+  return (logLevels as any)[name.toLocaleLowerCase()]
+}

package/ts/logStore.ts

@@ -0,0 +1,52 @@
+
+import { mapKey, reduceByKey, reduceKey } from 'type-plus'
+import { createConsoleLogReporter } from './console.js'
+import { logLevels, toLogLevel, toLogLevelName } from './logLevels.js'
+import type { Logger, LogLevel, LogReporter, StandardLogOptions } from './types.js'
+
+export function createLogStore(options: StandardLogOptions): LogStore {
+  return {
+    loggers: {},
+    reporters: options.reporters || [createConsoleLogReporter()],
+    logLevel: options.logLevel,
+    logLevelStore: logLevelStore(options)
+  }
+}
+
+export interface LogStore {
+  loggers: Record<string, Logger>,
+  reporters: LogReporter[],
+  logLevel: LogLevel,
+  logLevelStore: ReturnType<typeof logLevelStore>
+}
+
+export interface LogLevelStoreOptions {
+  customLevels?: Record<string, number>
+}
+
+export function logLevelStore(options: LogLevelStoreOptions) {
+  const customLevels = options.customLevels || {}
+
+  const store = {
+    customLevels,
+    customLevelsReverse: reduceByKey(customLevels, (p, k) => {
+      p[customLevels[k]] = k
+      return p
+    }, {} as Record<number, string>)
+  }
+  return {
+    getName(level: number) {
+      return store.customLevelsReverse[level] ?? toLogLevelName(level)
+    },
+    getLevel(name: string) {
+      return store.customLevels[name] ?? toLogLevel(name)
+    },
+    getAllLevels() {
+      return reduceKey(logLevels, (result, name) => {
+        if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
+
+        return result
+      }, mapKey(store.customLevels, name => ({ name, level: store.customLevels[name] })))
+    }
+  }
+}

package/ts/logger.ts

@@ -0,0 +1,85 @@
+import type { StackTraceMeta } from '@just-func/types'
+import { RequiredPick } from 'type-plus'
+import { InvalidId } from './errors.js'
+import { logLevels } from './logLevels.js'
+import { LogStore } from './logStore.js'
+import type { LogEntry, LogFunction, Logger, LoggerOptions, LogMethodNames, LogReporter } from './types.js'
+import { LogLevel } from './types.js'
+
+export function createLogger<T extends string = LogMethodNames>(
+  [store, id, { level, writeTo = () => true }]: [LogStore, string, RequiredPick<LoggerOptions, 'level'>],
+  meta?: StackTraceMeta
+): Logger {
+  validateId(id, meta)
+  const [filter, reporters]: [(reporterId: string) => boolean, LogReporter[]] = typeof writeTo === 'string'
+    ? [id => id === writeTo, store.reporters]
+    : writeTo instanceof RegExp
+      ? [id => writeTo.test(id), store.reporters]
+      : typeof writeTo === 'function'
+        ? [writeTo, store.reporters]
+        : [() => true, [writeTo]]
+
+  function write(entry: LogEntry) {
+    writeToReporters(reporters, 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(store, 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' ? store.logLevelStore.getLevel(level)! : level
+        if (shouldLog(store, logLevel, logger.level)) {
+          const methodName = store.logLevelStore.getName(logLevel)
+          const bindedMethod = logger[methodName].bind(logger)
+          const result = logFn(bindedMethod)
+          if (result) bindedMethod(result)
+        }
+      }
+    }
+  })
+  store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
+    Object.defineProperty(logger, name, {
+      writable: false,
+      value: (...args: any[]) => {
+        if (shouldLog(store, level, logger.level)) write({ id, level, args, timestamp: new Date() })
+      }
+    })
+  })
+  return logger
+}
+
+function validateId(id: string, meta?: StackTraceMeta) {
+  if (/[`~!#$%^&*()=+[\]{},|<>?]/.test(id)) throw new InvalidId(id, meta)
+}
+
+function writeToReporters(reporters: LogReporter[], logEntry: LogEntry, filter: (reporterId: string) => boolean) {
+  reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
+}
+
+/**
+ * Determines should you log.
+ * @param loggerLevel Log level of the logger.
+ * It can be undefined which the global log level will be used.
+ */
+function shouldLog(store: LogStore, targetLevel: LogLevel, loggerLevel: LogLevel | undefined) {
+  return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel)
+}

package/ts/memory.ts

@@ -0,0 +1,47 @@
+import { required } from 'type-plus'
+import { toInspectLogEntry } from './platform.js'
+import { formatLogLevel } from './formatter.js'
+import type { LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './types.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>
+
+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 { id, formatter, filter } = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
+  const logs: LogEntry[] = []
+  return Object.freeze({
+    id,
+    get formatter() { return formatter },
+    get filter() { return filter },
+    logs,
+    write(entry: LogEntry) {
+      if (filter && !filter(entry)) return
+      logs.push(formatter(entry))
+    },
+    getLogMessage() {
+      return logs.map(toInspectLogEntry)
+        .map(log => log.args.join(' '))
+        .join('\n')
+    },
+    getLogMessageWithLevel() { return toMessageWithLevel(logs) }
+  })
+}

package/ts/platform.browser.ts

@@ -0,0 +1,8 @@
+import type { ConsoleLike, LogEntry } from './types.js'
+
+export const toInspectLogEntry = (e: LogEntry) => e
+export function isConsoleDebugAvailable() {
+  return true
+}
+
+export const polyfill: { console?: ConsoleLike } = {}

package/ts/platform.ts

@@ -0,0 +1,25 @@
+import { inspect } from 'util'
+import type { ConsoleLike, LogEntry } from './types.js'
+
+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])
+}
+
+// istanbul ignore next
+export function isConsoleDebugAvailable() {
+  // 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])
+}
+
+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 } = {}

package/ts/standardLog.ts

@@ -0,0 +1,54 @@
+import { StackTraceMeta } from '@just-func/types'
+import { required } from 'type-plus'
+import { createLogger } from './logger.js'
+import { logLevels } from './logLevels.js'
+import { createLogStore } from './logStore.js'
+import { createMemoryLogReporter } from './memory.js'
+import type { Logger, LoggerOptions, LogLevel, LogMethodNames, StandardLogOptions } from './types.js'
+
+export interface StandardLog<N extends string = LogMethodNames> {
+  readonly logLevel: number,
+  toLogLevelName(level: number): string,
+  toLogLevel(name: N): number,
+  getLogger(params: [id: string, options?: LoggerOptions], meta?: StackTraceMeta): Logger<N>
+}
+
+export function createStandardLog<N extends string = LogMethodNames>(
+  options?: Partial<StandardLogOptions<N>>, _meta?: StackTraceMeta
+): Readonly<StandardLog<N>> {
+  const store = createLogStore(required({ logLevel: logLevels.info }, options))
+
+  return Object.freeze({
+    get logLevel() { return store.logLevel },
+
+    toLogLevelName(level: number) {
+      return store.logLevelStore.getName(level)
+    },
+    toLogLevel(name: string) {
+      return store.logLevelStore.getLevel(name)
+    },
+    getLogger([id, options]: [id: string, options?: LoggerOptions], meta?: StackTraceMeta): Logger<N> {
+      if (store.loggers[id]) return store.loggers[id] as any
+      const opt = required({ level: store.logLevel }, options)
+      return store.loggers[id] = createLogger([store, id, opt], { ssf: this.getLogger, ...meta }) as any
+    }
+  })
+}
+
+export function createStandardLogForTest(logLevel: LogLevel = logLevels.debug) {
+  const reporter = createMemoryLogReporter()
+  const standardLog = createStandardLog({ reporters: [reporter], logLevel })
+  return { ...standardLog, reporter }
+}
+
+/**
+ * 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
+}