@stacksjs/events 0.65.0 → 0.67.0

package/dist/index.js

@@ -1,5 +1,2 @@
 // @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};
-
-//# debugId=2911EB3D08A281C964756E2164756E21
-//# sourceMappingURL=index.js.map
+function A(k){if(!k)k=new Map;return{all:k,on(w,j){let b=k.get(w);if(b)b.push(j);else k.set(w,[j])},off(w,j){let b=k.get(w);if(b)if(j){let 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};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/events",
   "type": "module",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "Functional event emitting.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -19,17 +19,15 @@
   "keywords": ["events", "functional", "functions", "mitt", "stacks"],
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     },
     "./*": {
-      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist", "src"],
+  "files": ["README.md", "dist"],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
@@ -37,6 +35,6 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.64.6"
+    "@stacksjs/development": "0.67.0"
   }
 }

package/dist/index.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": [
-    "// 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": ";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/src/index.ts

@@ -1,167 +0,0 @@
-// 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
-// and should not return a value
-export type Handler<T = unknown> = (event: T) => void
-export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void
-
-// An array of all currently registered event handlers for a type
-export type EventHandlerList<T = unknown> = Array<Handler<T>>
-export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>
-
-// A map of event types and their corresponding event handlers.
-export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
-  keyof Events | '*',
-  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
->
-
-export interface Emitter<Events extends Record<EventType, unknown>> {
-  all: EventHandlerMap<Events>
-
-  on: (<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) => void) &
-    ((type: '*', handler: WildcardHandler<Events>) => void)
-
-  off: (<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void) &
-    ((type: '*', handler?: WildcardHandler<Events>) => void)
-
-  emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) &
-    (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void)
-}
-
-/**
- * Tiny (~200b) functional event emitter / pubsub.
- */
-export default function mitt<Events extends Record<EventType, unknown>>(
-  all?: EventHandlerMap<Events>,
-): Emitter<Events> {
-  if (!all)
-    all = new Map()
-
-  return {
-    /**
-     * A Map of event names to registered handler functions.
-     */
-    all,
-
-    /**
-     * Register an event handler for the given type.
-     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
-     * @param {Function} handler Function to call in response to given event
-     * @memberOf mitt
-     */
-    on<Key extends keyof Events>(type: Key | '*', handler: Handler<Events[Key]> | WildcardHandler<Events>) {
-      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>)
-      }
-      // Explicitly assert the type of the handler array being set in the map. Unsure if there is a better way to do this
-      else {
-        (all as EventHandlerMap<Events>).set(type, [handler] as
-        | EventHandlerList<Events[keyof Events]>
-        | WildCardEventHandlerList<Events>)
-      }
-    },
-
-    /**
-     * Remove an event handler for the given type.
-     * If `handler` is omitted, all handlers of the given type are removed.
-     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
-     * @param {Function} [handler] Handler function to remove
-     * @memberOf mitt
-     */
-    off<Key extends keyof Events>(type: Key | '*', handler?: Handler<Events[Key]> | WildcardHandler<Events>) {
-      const handlers: Array<Handler<Events[Key]> | WildcardHandler<Events>> | undefined = (
-        all as EventHandlerMap<Events>
-      ).get(type)
-      if (handlers) {
-        if (handler) {
-          const index = handlers.indexOf(handler as Handler<Events[Key]> | WildcardHandler<Events>)
-          if (index > -1)
-            handlers.splice(index, 1)
-        }
-        else {
-          ;(all as EventHandlerMap<Events>).set(type, [])
-        }
-      }
-    },
-
-    /**
-     * Invoke all handlers for the given type.
-     * If present, `'*'` handlers are invoked after type-matched handlers.
-     *
-     * Note: Manually firing '*' handlers is not supported.
-     *
-     * @param {string|symbol} type The event type to invoke
-     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
-     * @memberOf mitt
-     */
-    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
-      let handlers = (all as EventHandlerMap<Events>).get(type)
-      if (handlers) {
-        ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {
-          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)
-        })
-      }
-    },
-  }
-}
-
-/**
- * This module provides a simple, yet powerful, event bus for the application.
- *
- * TODO: https://vitejs.dev/guide/api-plugin.html#typescript-for-custom-events
- *
- * @example To fire an event, you may use any of the following approaches:
- * ```ts
- * useEvent('user:registered', { name: 'Chris'})
- * dispatch('user:registered', { name: 'Chris'})
- *
- * // alternatively, you may use the following:
- * events.emit('user:registered', { name: 'Chris'})
- * useEvents.emit('user:registered', { name: 'Chris'})
- * ````
- *
- * @example To capture an event, you may use any of the following approaches:
- * ```ts
- * useListen('user:registered', (user) => console.log(user))
- * listen('user:registered', (user) => console.log(user))
- * ```
- */
-
-// TODO: need to create an action that auto generates this Events type from the ./app/Events
-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: Emitter<StacksEvents> = mitt<StacksEvents>()
-const emitter = events
-const useEvent: typeof emitter.emit = emitter.emit.bind(emitter)
-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
-
-export { all, dispatch, events, listen, mitt, off, useEvent, useEvents }