feat(helper): add macroable helper

Author: jlenon7

bin/test.ts

@@ -8,9 +8,11 @@
  */
 
 import { Runner } from '@athenna/test'
+import { expectTypeOf } from '@japa/expect-type'
 
 await Runner.setTsEnv()
   .addAssertPlugin()
+  .addPlugin(expectTypeOf())
   .addPath('tests/unit/**/*.ts')
   .setCliArgs(process.argv.slice(2))
   .setGlobalTimeout(5000)

package-lock.json

@@ -108,6 +108,7 @@
   "devDependencies": {
     "@athenna/test": "^5.2.0",
     "@athenna/tsconfig": "^5.0.0",
+    "@japa/expect-type": "^2.0.3",
     "@types/bytes": "^3.1.5",
     "@types/callsite": "^1.0.34",
     "@types/deasync": "^0.1.5",

package.json

@@ -9,8 +9,9 @@
 
 import { Is } from '#src/helpers/Is'
 import { Options } from '#src/helpers/Options'
+import { Macroable } from '#src/helpers/Macroable'
 
-export class Clean {
+export class Clean extends Macroable {
   /**
    * Remove all falsy values from an array.
    */

src/helpers/Clean.ts

@@ -11,15 +11,119 @@ import { Collection as CollectJS } from 'collect.js'
 
 export class Collection<T = any> extends CollectJS<T> {
   /**
-   * An alias for macro instance method:
+   * Add standard property to your class prototype.
    *
    * @example
-   *  Collection.macro('upperAndTrim', (value) => {
-   *    return value.trim().toUpperCase()
-   *  })
+   * ```ts
+   * YourClass.macro('foo', 'bar')
+   * ```
+   */
+  public static macro<K extends keyof Collection>(
+    name: K,
+    value: Collection[K]
+  ) {
+    this.prototype[name] = value
+  }
+
+  /**
+   * Add getters to the class prototype using the Object.defineProperty()
+   * method.
+   *
+   * @example
+   * ```ts
+   * YourClass.getter('foo', function foo () {
+   *  return 'bar'
+   * })
+   *
+   * const singleton = true
+   *
+   * // Add singleton getter:
+   * YourClass.getter('foo', function foo() {
+   *  return 'bar'
+   * }, singleton)
+   * ```
    */
-  public static macro(name: string, fn: any): void {
-    return new Collection().macro(name, fn)
+  public static getter<K extends keyof Collection>(
+    name: K,
+    accumulator: () => Collection[K],
+    singleton: boolean = false
+  ) {
+    Object.defineProperty(this.prototype, name, {
+      get() {
+        const value = accumulator.call(this)
+
+        if (singleton) {
+          Object.defineProperty(this, name, {
+            configurable: false,
+            enumerable: false,
+            value,
+            writable: false
+          })
+        }
+
+        return value
+      },
+      configurable: true,
+      enumerable: false
+    })
+  }
+
+  /**
+   * Add a standard static property to the class itself.
+   *
+   * @example
+   * ```ts
+   * YourClass.staticMacro('foo', 'bar')
+   * ```
+   */
+  public static staticMacro<K extends keyof Collection>(
+    name: K,
+    value: Collection[K]
+  ) {
+    Object.defineProperty(this, name, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    })
+  }
+
+  /**
+   * Add static getters to the class itself using Object.defineProperty().
+   *
+   * @example
+   * ```ts
+   * YourClass.staticGetter('foo', () => 'bar')
+   *
+   * const singleton = true
+   *
+   * // Add singleton static getter:
+   * YourClass.staticGetter('foo', () => 'bar', singleton)
+   * ```
+   */
+  public static staticGetter<K extends keyof Collection>(
+    name: K,
+    accumulator: () => Collection[K],
+    singleton: boolean = false
+  ) {
+    Object.defineProperty(this, name, {
+      get: function () {
+        const value = accumulator.call(this)
+
+        if (singleton) {
+          Object.defineProperty(this, name, {
+            configurable: false,
+            enumerable: true,
+            value,
+            writable: false
+          })
+        }
+
+        return value
+      },
+      configurable: true,
+      enumerable: true
+    })
   }
 
   /**

src/helpers/Collection.ts

@@ -10,8 +10,9 @@
 import { format } from 'node:util'
 import { Is } from '#src/helpers/Is'
 import { Chalk, type ChalkInstance } from 'chalk'
+import { Macroable } from '#src/helpers/Macroable'
 
-export class Color {
+export class Color extends Macroable {
   /**
    * Chalk instance.
    */

src/helpers/Color.ts

@@ -7,7 +7,9 @@
  * file that was distributed with this source code.
  */
 
-export class Enum {
+import { Macroable } from '#src/helpers/Macroable'
+
+export class Enum extends Macroable {
   /**
    * Get all keys from enum.
    *

src/helpers/Enum.ts

@@ -22,11 +22,12 @@ import { Transform } from 'node:stream'
 import { File } from '#src/helpers/File'
 import { Path } from '#src/helpers/Path'
 import { Options } from '#src/helpers/Options'
+import { Macroable } from '#src/helpers/Macroable'
 import { request as requestHttp } from 'node:http'
 import { request as requestHttps } from 'node:https'
 import { execa, execaNode, execaCommand, type ExecaChildProcess } from 'execa'
 
-export class Exec {
+export class Exec extends Macroable {
   /**
    * Sleep the code in the line that this function
    * is being called.

src/helpers/Exec.ts

@@ -15,9 +15,10 @@ import { File } from '#src/helpers/File'
 import { Path } from '#src/helpers/Path'
 import { Json } from '#src/helpers/Json'
 import { Folder } from '#src/helpers/Folder'
+import { Macroable } from '#src/helpers/Macroable'
 import type { FastifyInstance, HTTPMethods, RouteOptions } from 'fastify'
 
-export class FakeApi {
+export class FakeApi extends Macroable {
   /**
    * Set if the FakeApi server is running.
    */

src/helpers/FakeApi.ts

@@ -10,6 +10,7 @@
 import prependFile from 'prepend-file'
 
 import type { StreamOptions } from 'node:stream'
+import { Macroable } from '#src/helpers/Macroable'
 import type { FileJson, ObjectBuilderOptions } from '#src/types'
 
 import {
@@ -40,7 +41,7 @@ import { isAbsolute, parse, sep } from 'node:path'
 import { Json, ObjectBuilder } from '#src/helpers/Json'
 import { NotFoundFileException } from '#src/exceptions/NotFoundFileException'
 
-export class File {
+export class File extends Macroable {
   /**
    * The original or faked file directory.
    */
@@ -147,6 +148,8 @@ export class File {
     mockedValues = false,
     isCopy = false
   ) {
+    super()
+
     const { ext, dir, name, base, mime, path } = File.parsePath(filePath)
 
     this.originalDir = dir