@stacksjs/events 0.59.11 → 0.61.1

package/dist/index.js

@@ -1,7 +1,8 @@
 // @bun
 // src/index.ts
 function mitt(all) {
-  all = all || new Map;
+  if (!all)
+    all = new Map;
   return {
     all,
     on(type, handler) {
@@ -14,29 +15,28 @@ function mitt(all) {
     off(type, handler) {
       const handlers = all.get(type);
       if (handlers) {
-        if (handler)
-          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-        else
+        if (handler) {
+          const index = handlers.indexOf(handler);
+          if (index > -1)
+            handlers.splice(index, 1);
+        } else {
           all.set(type, []);
+        }
       }
     },
     emit(type, evt) {
       let handlers = all.get(type);
       if (handlers) {
-        handlers.slice().map((handler) => {
-          if (evt)
-            return handler(evt);
-          console.error("No event provided");
-          return "No event provided";
+        handlers.slice().forEach((handler) => {
+          if (evt !== undefined)
+            handler(evt);
         });
       }
       handlers = all.get("*");
       if (handlers) {
-        handlers.slice().map((handler) => {
-          if (evt)
-            return handler(type, evt);
-          console.error("No event provided");
-          return "No event provided";
+        handlers.slice().forEach((handler) => {
+          if (evt !== undefined)
+            handler(type, evt);
         });
       }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/events",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.1",
   "description": "Functional event emitting.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/index.ts

@@ -5,10 +5,7 @@ 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
+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>>
@@ -23,26 +20,25 @@ export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
 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)
+  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)
+  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)
+  emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) &
+    (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void)
 }
 
 /**
- * A tiny (~200b) functional event emitter / pubsub.
+ * Tiny (~200b) functional event emitter / pubsub.
  */
 export default function mitt<Events extends Record<EventType, unknown>>(
   all?: EventHandlerMap<Events>,
 ): Emitter<Events> {
-  type GenericEventHandler =
-    | Handler<Events[keyof Events]>
-    | WildcardHandler<Events>
-  all = all || new Map()
+  if (!all) all = new Map()
 
   return {
-
     /**
      * A Map of event names to registered handler functions.
      */
@@ -54,13 +50,16 @@ export default function mitt<Events extends Record<EventType, unknown>>(
      * @param {Function} handler Function to call in response to given event
      * @memberOf mitt
      */
-    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {
-      const handlers: Array<GenericEventHandler> | undefined = all!.get(type)
-      if (handlers)
-        handlers.push(handler)
-
+    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!.set(type, [handler] as EventHandlerList<Events[keyof Events]>)
+        (all as EventHandlerMap<Events>).set(type, [handler] as
+          | EventHandlerList<Events[keyof Events]>
+          | WildCardEventHandlerList<Events>)
     },
 
     /**
@@ -70,14 +69,17 @@ export default function mitt<Events extends Record<EventType, unknown>>(
      * @param {Function} [handler] Handler function to remove
      * @memberOf mitt
      */
-    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
-      const handlers: Array<GenericEventHandler> | undefined = all!.get(type)
+    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)
-          handlers.splice(handlers.indexOf(handler) >>> 0, 1)
-
-        else
-          all!.set(type, [])
+        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, [])
+        }
       }
     },
 
@@ -92,31 +94,17 @@ export default function mitt<Events extends Record<EventType, unknown>>(
      * @memberOf mitt
      */
     emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
-      let handlers = all!.get(type)
+      let handlers = (all as EventHandlerMap<Events>).get(type)
       if (handlers) {
-        (handlers as EventHandlerList<Events[keyof Events]>)
-          .slice()
-          .map((handler) => {
-            if (evt)
-              return handler(evt)
-
-            console.error('No event provided')
-            return 'No event provided'
-          })
+        ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {
+          if (evt !== undefined) handler(evt)
+        })
       }
-
-      handlers = all!.get('*')
+      handlers = (all as EventHandlerMap<Events>).get('*')
       if (handlers) {
-        (handlers as WildCardEventHandlerList<Events>)
-          .slice()
-        //
-          .map((handler: any) => {
-            if (evt)
-              return handler(type, evt)
-
-            console.error('No event provided')
-            return 'No event provided'
-          })
+        ;(handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {
+          if (evt !== undefined) handler(type, evt)
+        })
       }
     },
   }
@@ -144,8 +132,8 @@ 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
-interface Events {
+// 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 }
@@ -155,7 +143,7 @@ interface Events {
   'user:password-changed': { name: string }
 }
 
-const events = mitt<Events>
+const events = mitt<StacksEvents>
 const emitter = events()
 const useEvent: typeof emitter.emit = emitter.emit.bind(emitter)
 const useEvents = events()

package/dist/index.d.ts

@@ -1,25 +0,0 @@
-export type EventType = string | symbol;
-export type Handler<T = unknown> = (event: T) => void;
-export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
-export type EventHandlerList<T = unknown> = Array<Handler<T>>;
-export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
-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);
-}
-/**
- * A tiny (~200b) functional event emitter / pubsub.
- */
-export default function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
-declare const events: typeof mitt;
-declare const emitter: Emitter<Record<EventType, unknown>>;
-declare const useEvent: typeof emitter.emit;
-declare const useEvents: Emitter<Record<EventType, unknown>>;
-declare const dispatch: typeof emitter.emit;
-declare const listen: typeof emitter.on;
-declare const off: typeof emitter.off;
-declare const all: typeof emitter.all;
-export { all, dispatch, events, listen, mitt, off, useEvent, useEvents };