🪄 Mimikrook

🎣🔗 Mimikrook: Awaitable hooks for seamless code enhancement! 💪💡 Boost your development with the power of hooks. 🚀

📦 Install:

Using yarn:

# nyxi
nyxi mimikrook

# pnpm
pnpm add mimikrook

# npm
npm i mimikrook

# yarn
yarn add mimikrook

📘 Usage

Method 🅰️: Create a mimikrook instance:

import { createHooks } from 'mimikrook'

// Create a mimikrook instance
const hooks = createHooks()

// Hook on 'hello'
hooks.hook('hello', () => { console.log('Hello World') })

// Call 'hello' hook
hooks.callHook('hello')

Method 🅱️: Extend your base class from Mimikrook:

import { Mimikrook } from 'mimikrook'

export default class FooLib extends Mimikrook {
   constructor() {
      // Call to parent to initialize
      super()
      // Initialize Mimikrook with custom logger
      // super(consola)
   }

   async someFunction() {
      // Call and wait for `hook1` hooks (if any) sequential
      await this.callHook('hook1')
   }
}

🔌 Inside plugins, register for any hook:

const lib = new FooLib()

// Register a handler for `hook2`
lib.hook('hook2', async () => { /* ... */ })

// Register multiply handlers at once
lib.addHooks({
   hook1: async () => { /* ... */ },
   hook2: []
})

🗑️ Unregistering hooks:

const lib = new FooLib()

async function hook0() { /* ... */ }
async function hook1() { /* ... */ }
async function hook2() { /* ... */ }

// The hook() method returns an "unregister" function
const unregisterHook0 = lib.hook('hook0', hook0)
const unregisterHooks1and2 = lib.addHooks({ hook1, hook2 })

/* ... */

unregisterHook0()
unregisterHooks1and2()

// or

lib.removeHooks({ hook0, hook1 })
lib.removeHook('hook2', hook2)

🔂 Triggering a hook handler once:

const lib = new FooLib()

const unregister = lib.hook('hook0', async () => {
   // Unregister as soon as the hook is executed
   unregister()

   /* ... */
})

🏫 Mimikrook class

🏗️ `constructor()`

🪝 `hook (name, fn)`

Returns an unregister function that, when called, will remove the registered handler.

🕒 `hookOnce (name, fn)`

Similar to hook but unregisters hook once called.

Returns an unregister function that, when called, will remove the registered handler before first call.

📐 `addHooks(configHooks)`

Flatten and register hooks object.

💡Example:

mimikrook.addHooks({
   test: {
      before: () => {},
      after: () => {}
   }
})

This registers test:before and test:after hooks at bulk.

Returns an unregister function that, when called, will remove all the registered handlers.

📞 `async callHook (name, ...args)`

Used by class itself to sequentially call handlers of a specific hook.

📞 `callHookWith (name, callerFn)`

If you need custom control over how hooks are called, you can provide a custom function that will receive an array of handlers of a specific hook.

callerFn if a callback function that accepts two arguments, hooks and args:

hooks: Array of user hooks to be called
args: Array of arguments that should be passed each time calling a hook

⚠️ `deprecateHook (old, name)`

Deprecate hook called old in favor of name hook.

⚠️ `deprecateHooks (deprecatedHooks)`

Deprecate all hooks from an object (keys are old and values or newer ones).

🗑️ `removeHook (name, fn)`

Remove a particular hook handler, if the fn handler is present.

🗑️ `removeHooks (configHooks)`

Remove multiple hook handlers.

💡 Example:

async function handler() { /* ... */ }

mimikrook.hook('test:before', handler)
mimikrook.addHooks({ test: { after: handler } })

// ...

mimikrook.removeHooks({
   test: {
      before: handler,
      after: handler
   }
})

🗑️ `removeAllHooks`

Remove all hook handlers.

⏮️ `beforeEach (syncCallback)`

Registers a (sync) callback to be called before each hook is being called.

mimikrook.beforeEach((event) => { console.log(`${event.name} hook is being called with ${event.args}`)}`)
mimikrook.hook('test', () => { console.log('running test hook') })

// test hook is being called with []
// running test hook
await mimikrook.callHook('test')

⏭️ `afterEach (syncCallback)`

Registers a (sync) callback to be called after each hook is being called.

mimikrook.afterEach((event) => { console.log(`${event.name} hook called with ${event.args}`)}`)
mimikrook.hook('test', () => { console.log('running test hook') })

// running test hook
// test hook called with []
await mimikrook.callHook('test')

🔍 `createDebugger`

Automatically logs each hook that is called and how long it takes to run.

const debug = mimikrook.createDebugger(hooks, { tag: 'something' })

hooks.callHook('some-hook', 'some-arg')
// [something] some-hook: 0.21ms

debug.close()

🐙 Clone this repository 🔧 Enable Corepack using corepack enable 📦 Install dependencies using nyxi 🧙 Always right package manager

📜 License

MIT - Made with 💞

nyxblabs / mimikrook Goto Github PK

mimikrook's Introduction

🪄 Mimikrook

📦 Install:

📘 Usage

🏫 Mimikrook class

🏗️ constructor()

🪝 hook (name, fn)

🕒 hookOnce (name, fn)

📐 addHooks(configHooks)

📞 async callHook (name, ...args)

📞 callHookWith (name, callerFn)

⚠️ deprecateHook (old, name)

⚠️ deprecateHooks (deprecatedHooks)

🗑️ removeHook (name, fn)

🗑️ removeHooks (configHooks)

🗑️ removeAllHooks

⏮️ beforeEach (syncCallback)

⏭️ afterEach (syncCallback)

🔍 createDebugger