@stacksjs/events 0.64.6 → 0.65.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // @bun
-function A(k){if(!k)k=new Map;return{all:k,on(w,j){const b=k.get(w);if(b)b.push(j);else k.set(w,[j])},off(w,j){const b=k.get(w);if(b)if(j){const z=b.indexOf(j);if(z>-1)b.splice(z,1)}else k.set(w,[])},emit(w,j){let b=k.get(w);if(b)b.slice().forEach((z)=>{if(j!==void 0)z(j)});if(b=k.get("*"),b)b.slice().forEach((z)=>{if(j!==void 0)z(w,j)})}}}var B=A,q=B(),C=q.emit.bind(q),F=B(),G=q.emit.bind(q),H=q.on.bind(q),I=q.off.bind(q),J=q.all;export{F as useEvents,C as useEvent,I as off,A as mitt,H as listen,B as events,G as dispatch,A as default,J as all};
+function A(k){if(!k)k=new Map;return{all:k,on(w,j){const b=k.get(w);if(b)b.push(j);else k.set(w,[j])},off(w,j){const b=k.get(w);if(b)if(j){const z=b.indexOf(j);if(z>-1)b.splice(z,1)}else k.set(w,[])},emit(w,j){let b=k.get(w);if(b)b.slice().forEach((z)=>{if(j!==void 0)z(j)});if(b=k.get("*"),b)b.slice().forEach((z)=>{if(j!==void 0)z(w,j)})}}}var B=A(),q=B,C=q.emit.bind(q),F=B,G=q.emit.bind(q),H=q.on.bind(q),I=q.off.bind(q),J=q.all;export{F as useEvents,C as useEvent,I as off,A as mitt,H as listen,B as events,G as dispatch,A as default,J as all};
 
-//# debugId=1AA49E97F6FD90FD64756E2164756E21
+//# debugId=2911EB3D08A281C964756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../src/index.ts"],
   "sourcesContent": [
-    "// thanks to mitt for the base of this wonderful functional event emitter\n\nexport type EventType = string | symbol\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void\nexport type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | '*',\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n  all: EventHandlerMap<Events>\n\n  on: (<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) => void) &\n    ((type: '*', handler: WildcardHandler<Events>) => void)\n\n  off: (<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void) &\n    ((type: '*', handler?: WildcardHandler<Events>) => void)\n\n  emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) &\n    (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void)\n}\n\n/**\n * Tiny (~200b) functional event emitter / pubsub.\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n  all?: EventHandlerMap<Events>,\n): Emitter<Events> {\n  if (!all) all = new Map()\n\n  return {\n    /**\n     * A Map of event names to registered handler functions.\n     */\n    all,\n\n    /**\n     * Register an event handler for the given type.\n     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n     * @param {Function} handler Function to call in response to given event\n     * @memberOf mitt\n     */\n    on<Key extends keyof Events>(type: Key | '*', handler: Handler<Events[Key]> | WildcardHandler<Events>) {\n      const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (\n        all as EventHandlerMap<Events>\n      ).get(type)\n      if (handlers) handlers.push(handler as Handler<Events[Key]> | WildcardHandler<Events>)\n      // Explicitly assert the type of the handler array being set in the map. Unsure if there is a better way to do this\n      else\n        (all as EventHandlerMap<Events>).set(type, [handler] as\n          | EventHandlerList<Events[keyof Events]>\n          | WildCardEventHandlerList<Events>)\n    },\n\n    /**\n     * Remove an event handler for the given type.\n     * If `handler` is omitted, all handlers of the given type are removed.\n     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n     * @param {Function} [handler] Handler function to remove\n     * @memberOf mitt\n     */\n    off<Key extends keyof Events>(type: Key | '*', handler?: Handler<Events[Key]> | WildcardHandler<Events>) {\n      const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (\n        all as EventHandlerMap<Events>\n      ).get(type)\n      if (handlers) {\n        if (handler) {\n          const index = handlers.indexOf(handler as Handler<Events[Key]> | WildcardHandler<Events>)\n          if (index > -1) handlers.splice(index, 1)\n        } else {\n          ;(all as EventHandlerMap<Events>).set(type, [])\n        }\n      }\n    },\n\n    /**\n     * Invoke all handlers for the given type.\n     * If present, `'*'` handlers are invoked after type-matched handlers.\n     *\n     * Note: Manually firing '*' handlers is not supported.\n     *\n     * @param {string|symbol} type The event type to invoke\n     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n     * @memberOf mitt\n     */\n    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n      let handlers = (all as EventHandlerMap<Events>).get(type)\n      if (handlers) {\n        ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {\n          if (evt !== undefined) handler(evt)\n        })\n      }\n      handlers = (all as EventHandlerMap<Events>).get('*')\n      if (handlers) {\n        ;(handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {\n          if (evt !== undefined) handler(type, evt)\n        })\n      }\n    },\n  }\n}\n\n/**\n * This module provides a simple, yet powerful, event bus for the application.\n *\n * TODO: https://vitejs.dev/guide/api-plugin.html#typescript-for-custom-events\n *\n * @example To fire an event, you may use any of the following approaches:\n * ```ts\n * useEvent('user:registered', { name: 'Chris'})\n * dispatch('user:registered', { name: 'Chris'})\n *\n * // alternatively, you may use the following:\n * events.emit('user:registered', { name: 'Chris'})\n * useEvents.emit('user:registered', { name: 'Chris'})\n * ````\n *\n * @example To capture an event, you may use any of the following approaches:\n * ```ts\n * useListen('user:registered', (user) => console.log(user))\n * listen('user:registered', (user) => console.log(user))\n * ```\n */\n\n// TODO: need to create an action that auto generates this Events type from the ./app/Events\ntype StacksEvents = {\n  'user:registered': { name: string }\n  'user:logged-in': { name: string }\n  'user:logged-out': { name: string }\n  'user:updated': { name: string }\n  'user:created': { name: string }\n  'user:deleted': { name: string }\n  'user:password-reset': { name: string }\n  'user:password-changed': { name: string }\n}\n\nconst events = mitt<StacksEvents>\nconst emitter = events()\nconst useEvent: typeof emitter.emit = emitter.emit.bind(emitter)\nconst useEvents = events()\nconst dispatch: typeof emitter.emit = emitter.emit.bind(emitter)\nconst listen: typeof emitter.on = emitter.on.bind(emitter)\nconst off: typeof emitter.off = emitter.off.bind(emitter)\nconst all: typeof emitter.all = emitter.all\n\nexport { all, dispatch, events, listen, mitt, off, useEvent, useEvents }\n"
+    "// thanks to mitt for the base of this wonderful functional event emitter\n\nimport type { UserModel } from '../../../orm/src/models/User'\n\nexport type EventType = string | symbol\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void\nexport type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | '*',\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n  all: EventHandlerMap<Events>\n\n  on: (<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) => void) &\n    ((type: '*', handler: WildcardHandler<Events>) => void)\n\n  off: (<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void) &\n    ((type: '*', handler?: WildcardHandler<Events>) => void)\n\n  emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) &\n    (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void)\n}\n\n/**\n * Tiny (~200b) functional event emitter / pubsub.\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n  all?: EventHandlerMap<Events>,\n): Emitter<Events> {\n  if (!all)\n    all = new Map()\n\n  return {\n    /**\n     * A Map of event names to registered handler functions.\n     */\n    all,\n\n    /**\n     * Register an event handler for the given type.\n     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n     * @param {Function} handler Function to call in response to given event\n     * @memberOf mitt\n     */\n    on<Key extends keyof Events>(type: Key | '*', handler: Handler<Events[Key]> | WildcardHandler<Events>) {\n      const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (\n        all as EventHandlerMap<Events>\n      ).get(type)\n      if (handlers) {\n        handlers.push(handler as Handler<Events[Key]> | WildcardHandler<Events>)\n      }\n      // Explicitly assert the type of the handler array being set in the map. Unsure if there is a better way to do this\n      else {\n        (all as EventHandlerMap<Events>).set(type, [handler] as\n        | EventHandlerList<Events[keyof Events]>\n        | WildCardEventHandlerList<Events>)\n      }\n    },\n\n    /**\n     * Remove an event handler for the given type.\n     * If `handler` is omitted, all handlers of the given type are removed.\n     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n     * @param {Function} [handler] Handler function to remove\n     * @memberOf mitt\n     */\n    off<Key extends keyof Events>(type: Key | '*', handler?: Handler<Events[Key]> | WildcardHandler<Events>) {\n      const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (\n        all as EventHandlerMap<Events>\n      ).get(type)\n      if (handlers) {\n        if (handler) {\n          const index = handlers.indexOf(handler as Handler<Events[Key]> | WildcardHandler<Events>)\n          if (index > -1)\n            handlers.splice(index, 1)\n        }\n        else {\n          ;(all as EventHandlerMap<Events>).set(type, [])\n        }\n      }\n    },\n\n    /**\n     * Invoke all handlers for the given type.\n     * If present, `'*'` handlers are invoked after type-matched handlers.\n     *\n     * Note: Manually firing '*' handlers is not supported.\n     *\n     * @param {string|symbol} type The event type to invoke\n     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n     * @memberOf mitt\n     */\n    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n      let handlers = (all as EventHandlerMap<Events>).get(type)\n      if (handlers) {\n        ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {\n          if (evt !== undefined)\n            handler(evt)\n        })\n      }\n      handlers = (all as EventHandlerMap<Events>).get('*')\n      if (handlers) {\n        ;(handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {\n          if (evt !== undefined)\n            handler(type, evt)\n        })\n      }\n    },\n  }\n}\n\n/**\n * This module provides a simple, yet powerful, event bus for the application.\n *\n * TODO: https://vitejs.dev/guide/api-plugin.html#typescript-for-custom-events\n *\n * @example To fire an event, you may use any of the following approaches:\n * ```ts\n * useEvent('user:registered', { name: 'Chris'})\n * dispatch('user:registered', { name: 'Chris'})\n *\n * // alternatively, you may use the following:\n * events.emit('user:registered', { name: 'Chris'})\n * useEvents.emit('user:registered', { name: 'Chris'})\n * ````\n *\n * @example To capture an event, you may use any of the following approaches:\n * ```ts\n * useListen('user:registered', (user) => console.log(user))\n * listen('user:registered', (user) => console.log(user))\n * ```\n */\n\n// TODO: need to create an action that auto generates this Events type from the ./app/Events\ninterface StacksEvents {\n  'user:registered': object\n  'user:logged-in': object\n  'user:logged-out': object\n  'user:updated': Partial<UserModel>\n  'user:created': Partial<UserModel>\n  'user:deleted': Partial<UserModel>\n  'user:password-reset': object\n  'user:password-changed': object\n}\n\nconst events: Emitter<StacksEvents> = mitt<StacksEvents>()\nconst emitter = events\nconst useEvent: typeof emitter.emit = emitter.emit.bind(emitter)\nconst useEvents = events\nconst dispatch: typeof emitter.emit = emitter.emit.bind(emitter)\n\nconst listen: typeof emitter.on = emitter.on.bind(emitter)\nconst off: typeof emitter.off = emitter.off.bind(emitter)\nconst all: typeof emitter.all = emitter.all\n\nexport { all, dispatch, events, listen, mitt, off, useEvent, useEvents }\n"
   ],
-  "mappings": ";AAmCA,SAAwB,CAA+C,CACrE,EACiB,CACjB,IAAK,EAAK,EAAM,IAAI,IAEpB,MAAO,CAIL,MAQA,EAA4B,CAAC,EAAiB,EAAyD,CACrG,MAAM,EACJ,EACA,IAAI,CAAI,EACV,GAAI,EAAU,EAAS,KAAK,CAAyD,MAGnF,CAAC,EAAgC,IAAI,EAAM,CAAC,CAAO,CAEf,GAUxC,GAA6B,CAAC,EAAiB,EAA0D,CACvG,MAAM,EACJ,EACA,IAAI,CAAI,EACV,GAAI,EACF,GAAI,EAAS,CACX,MAAM,EAAQ,EAAS,QAAQ,CAAyD,EACxF,GAAI,EAAQ,GAAI,EAAS,OAAO,EAAO,CAAC,MAEvC,CAAC,EAAgC,IAAI,EAAM,CAAC,CAAC,GAepD,IAA8B,CAAC,EAAW,EAAmB,CAC3D,IAAI,EAAY,EAAgC,IAAI,CAAI,EACxD,GAAI,EACD,AAAC,EAAoD,MAAM,EAAE,QAAQ,CAAC,IAAY,CACjF,GAAI,IAAQ,OAAW,EAAQ,CAAG,EACnC,EAGH,GADA,EAAY,EAAgC,IAAI,GAAG,EAC/C,EACD,AAAC,EAA8C,MAAM,EAAE,QAAQ,CAAC,IAAY,CAC3E,GAAI,IAAQ,OAAW,EAAQ,EAAM,CAAG,EACzC,EAGP,EAqCF,IAAM,EAAS,EACT,EAAU,EAAO,EACjB,EAAgC,EAAQ,KAAK,KAAK,CAAO,EACzD,EAAY,EAAO,EACnB,EAAgC,EAAQ,KAAK,KAAK,CAAO,EACzD,EAA4B,EAAQ,GAAG,KAAK,CAAO,EACnD,EAA0B,EAAQ,IAAI,KAAK,CAAO,EAClD,EAA0B,EAAQ",
-  "debugId": "1AA49E97F6FD90FD64756E2164756E21",
+  "mappings": ";AAqCA,SAAwB,CAA+C,CACrE,EACiB,CACjB,IAAK,EACH,EAAM,IAAI,IAEZ,MAAO,CAIL,MAQA,EAA4B,CAAC,EAAiB,EAAyD,CACrG,MAAM,EACJ,EACA,IAAI,CAAI,EACV,GAAI,EACF,EAAS,KAAK,CAAyD,MAIvE,CAAC,EAAgC,IAAI,EAAM,CAAC,CAAO,CAEjB,GAWtC,GAA6B,CAAC,EAAiB,EAA0D,CACvG,MAAM,EACJ,EACA,IAAI,CAAI,EACV,GAAI,EACF,GAAI,EAAS,CACX,MAAM,EAAQ,EAAS,QAAQ,CAAyD,EACxF,GAAI,EAAQ,GACV,EAAS,OAAO,EAAO,CAAC,MAGzB,CAAC,EAAgC,IAAI,EAAM,CAAC,CAAC,GAepD,IAA8B,CAAC,EAAW,EAAmB,CAC3D,IAAI,EAAY,EAAgC,IAAI,CAAI,EACxD,GAAI,EACD,AAAC,EAAoD,MAAM,EAAE,QAAQ,CAAC,IAAY,CACjF,GAAI,IAAQ,OACV,EAAQ,CAAG,EACd,EAGH,GADA,EAAY,EAAgC,IAAI,GAAG,EAC/C,EACD,AAAC,EAA8C,MAAM,EAAE,QAAQ,CAAC,IAAY,CAC3E,GAAI,IAAQ,OACV,EAAQ,EAAM,CAAG,EACpB,EAGP,EAqCF,IAAM,EAAgC,EAAmB,EACnD,EAAU,EACV,EAAgC,EAAQ,KAAK,KAAK,CAAO,EACzD,EAAY,EACZ,EAAgC,EAAQ,KAAK,KAAK,CAAO,EAEzD,EAA4B,EAAQ,GAAG,KAAK,CAAO,EACnD,EAA0B,EAAQ,IAAI,KAAK,CAAO,EAClD,EAA0B,EAAQ",
+  "debugId": "2911EB3D08A281C964756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/events",
   "type": "module",
-  "version": "0.64.6",
+  "version": "0.65.0",
   "description": "Functional event emitting.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/events#readme",
@@ -15,13 +16,7 @@
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
   },
-  "keywords": [
-    "events",
-    "functional",
-    "functions",
-    "mitt",
-    "stacks"
-  ],
+  "keywords": ["events", "functional", "functions", "mitt", "stacks"],
   "exports": {
     ".": {
       "bun": "./src/index.ts",
@@ -34,20 +29,14 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
+    "test": "bun test.ts",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/development": "0.64.6"
   }
 }

package/src/index.ts

@@ -1,5 +1,7 @@
 // thanks to mitt for the base of this wonderful functional event emitter
 
+import type { UserModel } from '../../../orm/src/models/User'
+
 export type EventType = string | symbol
 
 // An event handler can take an optional event argument
@@ -36,7 +38,8 @@ export interface Emitter<Events extends Record<EventType, unknown>> {
 export default function mitt<Events extends Record<EventType, unknown>>(
   all?: EventHandlerMap<Events>,
 ): Emitter<Events> {
-  if (!all) all = new Map()
+  if (!all)
+    all = new Map()
 
   return {
     /**
@@ -54,12 +57,15 @@ export default function mitt<Events extends Record<EventType, unknown>>(
       const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (
         all as EventHandlerMap<Events>
       ).get(type)
-      if (handlers) handlers.push(handler as Handler<Events[Key]> | WildcardHandler<Events>)
+      if (handlers) {
+        handlers.push(handler as Handler<Events[Key]> | WildcardHandler<Events>)
+      }
       // Explicitly assert the type of the handler array being set in the map. Unsure if there is a better way to do this
-      else
+      else {
         (all as EventHandlerMap<Events>).set(type, [handler] as
-          | EventHandlerList<Events[keyof Events]>
-          | WildCardEventHandlerList<Events>)
+        | EventHandlerList<Events[keyof Events]>
+        | WildCardEventHandlerList<Events>)
+      }
     },
 
     /**
@@ -76,8 +82,10 @@ export default function mitt<Events extends Record<EventType, unknown>>(
       if (handlers) {
         if (handler) {
           const index = handlers.indexOf(handler as Handler<Events[Key]> | WildcardHandler<Events>)
-          if (index > -1) handlers.splice(index, 1)
-        } else {
+          if (index > -1)
+            handlers.splice(index, 1)
+        }
+        else {
           ;(all as EventHandlerMap<Events>).set(type, [])
         }
       }
@@ -97,13 +105,15 @@ export default function mitt<Events extends Record<EventType, unknown>>(
       let handlers = (all as EventHandlerMap<Events>).get(type)
       if (handlers) {
         ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {
-          if (evt !== undefined) handler(evt)
+          if (evt !== undefined)
+            handler(evt)
         })
       }
       handlers = (all as EventHandlerMap<Events>).get('*')
       if (handlers) {
         ;(handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {
-          if (evt !== undefined) handler(type, evt)
+          if (evt !== undefined)
+            handler(type, evt)
         })
       }
     },
@@ -133,22 +143,23 @@ export default function mitt<Events extends Record<EventType, unknown>>(
  */
 
 // TODO: need to create an action that auto generates this Events type from the ./app/Events
-type StacksEvents = {
-  'user:registered': { name: string }
-  'user:logged-in': { name: string }
-  'user:logged-out': { name: string }
-  'user:updated': { name: string }
-  'user:created': { name: string }
-  'user:deleted': { name: string }
-  'user:password-reset': { name: string }
-  'user:password-changed': { name: string }
+interface StacksEvents {
+  'user:registered': object
+  'user:logged-in': object
+  'user:logged-out': object
+  'user:updated': Partial<UserModel>
+  'user:created': Partial<UserModel>
+  'user:deleted': Partial<UserModel>
+  'user:password-reset': object
+  'user:password-changed': object
 }
 
-const events = mitt<StacksEvents>
-const emitter = events()
+const events: Emitter<StacksEvents> = mitt<StacksEvents>()
+const emitter = events
 const useEvent: typeof emitter.emit = emitter.emit.bind(emitter)
-const useEvents = events()
+const useEvents = events
 const dispatch: typeof emitter.emit = emitter.emit.bind(emitter)
+
 const listen: typeof emitter.on = emitter.on.bind(emitter)
 const off: typeof emitter.off = emitter.off.bind(emitter)
 const all: typeof emitter.all = emitter.all