⬅️ Back to Table of Contents

📄 index.ts

📊 Analysis Summary

Metric	Count
🔧 Functions	6
📦 Imports	2
📊 Variables & Constants	1
⚡ Async/Await Patterns	2
📐 Interfaces	1
📑 Type Aliases	5

📚 Table of Contents

• Imports
• Variables & Constants
• Async/Await Patterns
• Functions
• Interfaces
• Type Aliases

🛠️ File Location:

📂 packages/shared/createEventHook/index.ts

📦 Imports

Name	Source
IsAny	../utils/types
tryOnScopeDispose	../tryOnScopeDispose

---

Variables & Constants

Name	Type	Kind	Value	Exported
fns	Set<Callback<T>>	const	new Set()	✗

---

Async/Await Patterns

Type	Function	Await Expressions	Promise Chains
promise-chain	createEventHook	none	Promise.all
promise-chain	trigger	none	Promise.all

---

Functions

createEventHook(): EventHookReturn<T>

Code

export function createEventHook<T = any>(): EventHookReturn<T> {
  const fns: Set<Callback<T>> = new Set()

  const off = (fn: Callback<T>) => {
    fns.delete(fn)
  }

  const clear = () => {
    fns.clear()
  }

  const on = (fn: Callback<T>) => {
    fns.add(fn)
    const offFn = () => off(fn)

    tryOnScopeDispose(offFn)

    return {
      off: offFn,
    }
  }

  const trigger: EventHookTrigger<T> = (...args) => {
    return Promise.all(Array.from(fns).map(fn => fn(...args)))
  }

  return {
    on,
    off,
    trigger,
    clear,
  }
}

• JSDoc:

  /**
   * Utility for creating event hooks
   *
   * @see https://vueuse.org/createEventHook
   */
  

• Return Type: EventHookReturn<T>

• Calls:
• fns.delete
• fns.clear
• fns.add
• off
• tryOnScopeDispose (from ../tryOnScopeDispose)
• Promise.all
• Array.from(fns).map
• fn

off(fn: Callback<T>): void

Code

(fn: Callback<T>) => {
    fns.delete(fn)
  }

• Parameters:
• fn: Callback<T>
• Return Type: void
• Calls:
• fns.delete

clear(): void

Code

() => {
    fns.clear()
  }

• Return Type: void
• Calls:
• fns.clear

on(fn: Callback<T>): { off: () => void; }

Code

(fn: Callback<T>) => {
    fns.add(fn)
    const offFn = () => off(fn)

    tryOnScopeDispose(offFn)

    return {
      off: offFn,
    }
  }

• Parameters:
• fn: Callback<T>
• Return Type: { off: () => void; }
• Calls:
• fns.add
• off
• tryOnScopeDispose (from ../tryOnScopeDispose)

offFn(): void

Code

() => off(fn)

• Return Type: void
• Calls:
• off

trigger(args: Parameters<Callback<T>>): Promise<void[]>

Code

(...args) => {
    return Promise.all(Array.from(fns).map(fn => fn(...args)))
  }

• Parameters:
• args: Parameters<Callback<T>>
• Return Type: Promise<void[]>
• Calls:
• Promise.all
• Array.from(fns).map
• fn

---

Interfaces

EventHook<T = any>

Interface Code

export interface EventHook<T = any> {
  on: EventHookOn<T>
  off: EventHookOff<T>
  trigger: EventHookTrigger<T>
  clear: () => void
}

Properties

Name	Type	Optional	Description
on	EventHookOn<T>	✗
off	EventHookOff<T>	✗
trigger	EventHookTrigger<T>	✗
clear	() => void	✗

---

Type Aliases

Callback<T>

type Callback<T> = IsAny<T> extends true
  ? (...param: any) => void
  : (
      [T] extends [void]
        ? (...param: unknown[]) => void
        : [T] extends [any[]]
            ? (...param: T) => void
            : (...param: [T, ...unknown[]]) => void
    );

EventHookOn<T = any = any>

type EventHookOn<T = any = any> = (fn: Callback<T>) => { off: () => void };

EventHookOff<T = any = any>

type EventHookOff<T = any = any> = (fn: Callback<T>) => void;

EventHookTrigger<T = any = any>

type EventHookTrigger<T = any = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;

EventHookReturn<T>

type EventHookReturn<T> = EventHook<T>;

---