feat: experimental CommonLogger/SimpleLogger interfaces

Author: kirillgroshkov

src/index.ts

@@ -224,6 +224,14 @@ import {
 } from './types'
 import { _gb, _hb, _kb, _mb } from './unit/size.util'
 import { is } from './vendor/is'
+import {
+  CommonLogLevel,
+  CommonLogFunction,
+  CommonLogger,
+  SimpleLogger,
+  createSimpleLogger,
+  noopLogger,
+} from './log/commonLogger'
 
 export type {
   MemoCache,
@@ -295,6 +303,10 @@ export type {
   JsonSchemaArray,
   JsonSchemaTuple,
   JsonSchemaBuilder,
+  CommonLogLevel,
+  CommonLogFunction,
+  CommonLogger,
+  SimpleLogger,
 }
 
 export {
@@ -453,4 +465,6 @@ export {
   _defineLazyProperty,
   _defineLazyProps,
   _lazyValue,
+  createSimpleLogger,
+  noopLogger,
 }

src/log/commonLogger.test.ts

@@ -0,0 +1,26 @@
+import { CommonLogger, createSimpleLogger, noopLogger } from './commonLogger'
+
+// This "tests" that `console` is a valid CommonLogger by itself
+const consoleLogger: CommonLogger = console
+
+test('commonLogger', () => {
+  consoleLogger.log('hello')
+  consoleLogger.warn('hello')
+  consoleLogger.error('hello')
+})
+
+test('createSimpleLogger', () => {
+  const logger = createSimpleLogger(console)
+  logger('hey')
+  logger.log('hey')
+  logger.warn('hey')
+  logger.error('hey')
+})
+
+test('noopLogger', () => {
+  const logger = noopLogger
+  logger('hey')
+  logger.log('hey')
+  logger.warn('hey')
+  logger.error('hey')
+})

src/log/commonLogger.ts

@@ -0,0 +1,65 @@
+/**
+ * These levels follow console.* naming,
+ * so you can use console[level] safely.
+ *
+ * `log` is considered default level.
+ *
+ * For simplicity - only these 3 levels are kept.
+ *
+ * @experimental
+ */
+export type CommonLogLevel = 'log' | 'warn' | 'error'
+
+/**
+ * Function that takes any number of arguments and logs them all.
+ * It is expected that logged arguments are separated by "space", like console.log does.
+ *
+ * @experimental
+ */
+export type CommonLogFunction = (...args: any[]) => void
+
+/**
+ * Interface is inspired/compatible with `console.*`
+ * So, `console` is a valid CommonLogger implementation as-is.
+ *
+ * @experimental
+ */
+export interface CommonLogger {
+  log: CommonLogFunction
+  warn: CommonLogFunction
+  error: CommonLogFunction
+}
+
+/**
+ * Same as CommonLogger, but also is a "convenience function" itself.
+ * So you can do `logger('hey')` which is the same as `logger.log('hey')`
+ *
+ * @experimental
+ */
+export interface SimpleLogger extends CommonLogFunction, CommonLogger {}
+
+/**
+ * Creates a SimpleLogger from CommonLogger.
+ *
+ * @experimental
+ */
+export function createSimpleLogger(logger: CommonLogger): SimpleLogger {
+  return Object.assign(((...args: any[]) => logger.log(...args)) as any, {
+    log: (...args: any[]) => logger.log(...args),
+    warn: (...args: any[]) => logger.warn(...args),
+    error: (...args: any[]) => logger.error(...args),
+  })
+}
+
+const noop = () => {}
+
+/**
+ * SimpleLogger that does nothing (noop).
+ *
+ * @experimental
+ */
+export const noopLogger: SimpleLogger = createSimpleLogger({
+  log: noop,
+  warn: noop,
+  error: noop,
+})