refactor(reporters): Reporter#write -> Reporter#report

Signed-off-by: Lexus Drumgold <unicornware@flexdevelopment.llc>

Author: unicornware

src/lib/__tests__/create-logger.functional.spec.mts

@@ -28,7 +28,7 @@ describe('functional:lib/createLogger', () => {
          *
          * @return {undefined}
          */
-        public write(): undefined {
+        public report(): undefined {
           return void expect(this).to.have.property('logger', subject)
         }
       }
@@ -55,14 +55,14 @@ describe('functional:lib/createLogger', () => {
       logTypes.warn
     ])('should not send info above maximum log level (%#)', type => {
       // Arrange
-      vi.spyOn(reporter, 'write')
+      vi.spyOn(reporter, 'report')
 
       // Act
       subject.level = subject.levels.silent
       subject[type](type)
 
       // Expect
-      expect(reporter.write).not.toHaveBeenCalled()
+      expect(reporter.report).not.toHaveBeenCalled()
     })
 
     it.each<[type: LogType, message: unknown, ...args: unknown[]]>([
@@ -77,16 +77,16 @@ describe('functional:lib/createLogger', () => {
       }]
     ])('should send info to reporters (%#)', (type, message, ...args) => {
       // Arrange
-      const write: MockInstance<Reporter['write']> = vi.spyOn(reporter, 'write')
+      const spy: MockInstance<Reporter['report']> = vi.spyOn(reporter, 'report')
 
       // Act
       subject.level = subject.levels.verbose
       subject[type](message, ...args)
 
       // Expect
-      expect(write).toHaveBeenCalledOnce()
-      expect(write.mock.lastCall?.[0]).to.have.property('date').instanceof(Date)
-      expect(omit(write.mock.lastCall![0], ['date'])).toMatchSnapshot()
+      expect(spy).toHaveBeenCalledOnce()
+      expect(spy.mock.lastCall?.[0]).to.have.property('date').instanceof(Date)
+      expect(omit(spy.mock.lastCall![0], ['date'])).toMatchSnapshot()
     })
   })
 })

src/lib/create-logger.mts

@@ -21,7 +21,7 @@ import type {
   LogObject,
   LogType
 } from '@flex-development/log'
-import { keys } from '@flex-development/tutils'
+import { keys, type Fn } from '@flex-development/tutils'
 import { ok } from 'devlop'
 import isUnicodeSupported from 'is-unicode-supported'
 
@@ -178,8 +178,7 @@ function createLogger(
   logger.level = logger.normalizeLevel(options.level)
 
   for (const type of keys(logger.types)) {
-    Object.defineProperties(value, { name: { value: type } })
-    Object.defineProperties(logger, { [type]: { enumerable: true, value } })
+    bind(logger, type, send)
 
     /**
      * @this {Logger}
@@ -190,12 +189,12 @@ function createLogger(
      *  Message arguments
      * @return {undefined}
      */
-    function value(
+    function send(
       this: Logger,
       message: unknown,
       ...args: unknown[]
     ): undefined {
-      return void write.call(this, this.types[type], [message, ...args])
+      return void report.call(this, this.types[type], [message, ...args])
     }
   }
 
@@ -204,6 +203,39 @@ function createLogger(
   return logger
 }
 
+/**
+ * Bind a function to `logger`.
+ *
+ * @internal
+ *
+ * @this {void}
+ *
+ * @param {Partial<Logger>} logger
+ *  Logger object
+ * @param {keyof Logger} name
+ *  Function name
+ * @param {Fn} fn
+ *  The function to bind
+ * @return {undefined}
+ */
+function bind(
+  this: void,
+  logger: Partial<Logger>,
+  name: keyof Logger,
+  fn: Fn
+): undefined {
+  Object.defineProperties(logger, {
+    [name]: {
+      enumerable: true,
+      value: fn.bind(logger)
+    }
+  })
+
+  Object.defineProperties(logger[name], { name: { value: name } })
+
+  return void logger
+}
+
 /**
  * Send a message each log reporter.
  *
@@ -217,7 +249,7 @@ function createLogger(
  *  Message arguments
  * @return {undefined}
  */
-function write(
+function report(
   this: Logger,
   defaults: InputLogObject,
   args: unknown[]
@@ -257,7 +289,7 @@ function write(
     if (info.color === undefined) info.color = this.types[info.type].color
     if (info.icon === undefined) info.icon = this.types[info.type].icon
 
-    for (const reporter of this.reporters) void reporter.write(info)
+    for (const reporter of this.reporters) void reporter.report(info)
   }
 
   return void info

src/reporters/__tests__/abstract.reporter.spec-d.mts

@@ -11,8 +11,24 @@ describe('unit-d:reporters/Reporter', () => {
     expectTypeOf<TestSubject>().toHaveProperty('logger').toEqualTypeOf<Logger>()
   })
 
-  describe('write', () => {
-    type Subject = TestSubject['write']
+  describe('init', () => {
+    type Subject = TestSubject['init']
+
+    describe('parameters', () => {
+      it('should be callable with [Logger]', () => {
+        expectTypeOf<Subject>().parameters.toEqualTypeOf<[Logger]>()
+      })
+    })
+
+    describe('returns', () => {
+      it('should return undefined', () => {
+        expectTypeOf<Subject>().returns.toEqualTypeOf<undefined>()
+      })
+    })
+  })
+
+  describe('report', () => {
+    type Subject = TestSubject['report']
 
     describe('parameters', () => {
       it('should be callable with [LogObject]', () => {

src/reporters/abstract.reporter.mts

@@ -56,7 +56,7 @@ abstract class Reporter {
    *  The log information to process
    * @return {undefined | void}
    */
-  public abstract write(info: LogObject): undefined | void
+  public abstract report(info: LogObject): undefined | void
 }
 
 export default Reporter