utilful 1.2.0 → 1.2.1

package/README.md

@@ -137,7 +137,7 @@ emitter.on('*', (type, e) => console.log(type, e))
 emitter.emit('foo', { a: 'b' })
 
 // Clearing all events
-emitter.all.clear()
+emitter.events.clear()
 
 // Working with handler references:
 function onFoo() {}

package/dist/emitter.d.mts

@@ -5,7 +5,7 @@ type EventHandlerList<T = unknown> = Handler<T>[];
 type WildCardEventHandlerList<T = Record<string, unknown>> = WildcardHandler<T>[];
 type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
 interface Emitter<Events extends Record<EventType, unknown>> {
-    all: EventHandlerMap<Events>;
+    events: EventHandlerMap<Events>;
     on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
     on(type: '*', handler: WildcardHandler<Events>): void;
     off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
@@ -19,6 +19,6 @@ interface Emitter<Events extends Record<EventType, unknown>> {
  * @remarks Ported from `mitt`.
  * @see https://github.com/developit/mitt
  */
-declare function createEmitter<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
+declare function createEmitter<Events extends Record<EventType, unknown>>(events?: EventHandlerMap<Events>): Emitter<Events>;
 
 export { type Emitter, type EventHandlerList, type EventHandlerMap, type EventType, type Handler, type WildCardEventHandlerList, type WildcardHandler, createEmitter };

package/dist/emitter.d.ts

@@ -5,7 +5,7 @@ type EventHandlerList<T = unknown> = Handler<T>[];
 type WildCardEventHandlerList<T = Record<string, unknown>> = WildcardHandler<T>[];
 type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
 interface Emitter<Events extends Record<EventType, unknown>> {
-    all: EventHandlerMap<Events>;
+    events: EventHandlerMap<Events>;
     on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
     on(type: '*', handler: WildcardHandler<Events>): void;
     off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
@@ -19,6 +19,6 @@ interface Emitter<Events extends Record<EventType, unknown>> {
  * @remarks Ported from `mitt`.
  * @see https://github.com/developit/mitt
  */
-declare function createEmitter<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
+declare function createEmitter<Events extends Record<EventType, unknown>>(events?: EventHandlerMap<Events>): Emitter<Events>;
 
 export { type Emitter, type EventHandlerList, type EventHandlerMap, type EventType, type Handler, type WildCardEventHandlerList, type WildcardHandler, createEmitter };

package/dist/emitter.mjs

@@ -1,62 +1,61 @@
-function createEmitter(all) {
-  all ||= /* @__PURE__ */ new Map();
+function createEmitter(events) {
+  events ||= /* @__PURE__ */ new Map();
   return {
     /**
      * A Map of event names to registered handler functions.
      */
-    all,
+    events,
     /**
      * 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 createEmitter
      */
     on(type, handler) {
-      const handlers = all.get(type);
+      const handlers = events.get(type);
       if (handlers) {
         handlers.push(handler);
       } else {
-        all.set(type, [handler]);
+        events.set(type, [handler]);
       }
     },
     /**
      * Remove an event handler for the given type.
+     *
+     * @remarks
      * 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 createEmitter
      */
     off(type, handler) {
-      const handlers = all.get(type);
+      const handlers = events.get(type);
       if (handlers) {
         if (handler) {
           handlers.splice(handlers.indexOf(handler) >>> 0, 1);
         } else {
-          all.set(type, []);
+          events.set(type, []);
         }
       }
     },
     /**
      * Invoke all handlers for the given type.
-     * If present, `'*'` handlers are invoked after type-matched handlers.
      *
      * @remarks
+     * If present, `'*'` handlers are invoked after type-matched handlers.
      * 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 createEmitter
      */
     emit(type, evt) {
-      let handlers = all.get(type);
-      handlers?.slice().forEach((handler) => {
-        handler(evt);
-      });
-      handlers = all.get("*");
-      handlers?.slice().forEach((handler) => {
-        handler(type, evt);
-      });
+      let handlers = events.get(type);
+      if (handlers) {
+        for (const handler of [...handlers])
+          handler(evt);
+      }
+      handlers = events.get("*");
+      if (handlers) {
+        for (const handler of [...handlers])
+          handler(type, evt);
+      }
     }
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "utilful",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "packageManager": "pnpm@10.5.2",
   "description": "A collection of TypeScript utilities",
   "author": "Johann Schopplich <hello@johannschopplich.com>",