@stacksjs/events 0.56.35 → 0.57.2

package/dist/index.d.ts

@@ -1,6 +1,24 @@
-import mitt from 'mitt';
-export { default as mitt } from 'mitt';
-
+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;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export default function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
 /**
  * This module provides a simple, yet powerful, event bus for the application.
  *
@@ -24,22 +42,21 @@ export { default as mitt } from 'mitt';
  */
 declare const events: typeof mitt;
 declare const useEvent: {
-    <Key extends mitt.EventType>(type: Key, event: Record<mitt.EventType, unknown>[Key]): void;
-    <Key_1 extends mitt.EventType>(type: undefined extends Record<mitt.EventType, unknown>[Key_1] ? Key_1 : never): void;
+    <Key extends EventType>(type: Key, event: Record<EventType, unknown>[Key]): void;
+    <Key_1 extends EventType>(type: undefined extends Record<EventType, unknown>[Key_1] ? Key_1 : never): void;
 };
-declare const useEvents: mitt.Emitter<Record<mitt.EventType, unknown>>;
+declare const useEvents: Emitter<Record<EventType, unknown>>;
 declare const dispatch: {
-    <Key extends mitt.EventType>(type: Key, event: Record<mitt.EventType, unknown>[Key]): void;
-    <Key_1 extends mitt.EventType>(type: undefined extends Record<mitt.EventType, unknown>[Key_1] ? Key_1 : never): void;
+    <Key extends EventType>(type: Key, event: Record<EventType, unknown>[Key]): void;
+    <Key_1 extends EventType>(type: undefined extends Record<EventType, unknown>[Key_1] ? Key_1 : never): void;
 };
 declare const listen: {
-    <Key extends mitt.EventType>(type: Key, handler: mitt.Handler<Record<mitt.EventType, unknown>[Key]>): void;
-    (type: "*", handler: mitt.WildcardHandler<Record<mitt.EventType, unknown>>): void;
+    <Key extends EventType>(type: Key, handler: Handler<Record<EventType, unknown>[Key]>): void;
+    (type: '*', handler: WildcardHandler<Record<EventType, unknown>>): void;
 };
 declare const off: {
-    <Key extends mitt.EventType>(type: Key, handler?: mitt.Handler<Record<mitt.EventType, unknown>[Key]> | undefined): void;
-    (type: "*", handler: mitt.WildcardHandler<Record<mitt.EventType, unknown>>): void;
+    <Key extends EventType>(type: Key, handler?: Handler<Record<EventType, unknown>[Key]> | undefined): void;
+    (type: '*', handler: WildcardHandler<Record<EventType, unknown>>): void;
 };
-declare const all: mitt.EventHandlerMap<Record<mitt.EventType, unknown>>;
-
-export { all, dispatch, events, listen, off, useEvent, useEvents };
+declare const all: EventHandlerMap<Record<EventType, unknown>>;
+export { useEvent, useEvents, dispatch, listen, all, off, events, mitt };

package/dist/index.mjs

@@ -1,6 +1,65 @@
-import mitt from 'mitt';
-export { default as mitt } from 'mitt';
-
+export default function mitt(all2) {
+  all2 = all2 || /* @__PURE__ */ new Map();
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all: all2,
+    /**
+     * 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(type, handler) {
+      const handlers = all2.get(type);
+      if (handlers)
+        handlers.push(handler);
+      else
+        all2.set(type, [handler]);
+    },
+    /**
+     * 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(type, handler) {
+      const handlers = all2.get(type);
+      if (handlers) {
+        if (handler)
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        else
+          all2.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(type, evt) {
+      let handlers = all2.get(type);
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          return handler(evt);
+        });
+      }
+      handlers = all2.get("*");
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          return handler(type, evt);
+        });
+      }
+    }
+  };
+}
 const events = mitt;
 const emitter = events();
 const useEvent = emitter.emit;
@@ -9,5 +68,4 @@ const dispatch = emitter.emit;
 const listen = emitter.on;
 const off = emitter.off;
 const all = emitter.all;
-
-export { all, dispatch, events, listen, off, useEvent, useEvents };
+export { useEvent, useEvents, dispatch, listen, all, off, events, mitt };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/events",
   "type": "module",
-  "version": "0.56.35",
+  "version": "0.57.2",
   "packageManager": "pnpm@8.6.5",
   "description": "Functional event emitting.",
   "author": "Chris Breuer",
@@ -39,11 +39,10 @@
     "README.md"
   ],
   "peerDependencies": {
-    "mitt": "^3.0.0",
-    "@stacksjs/alias": "0.56.35"
+    "@stacksjs/alias": "0.57.2"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.56.35"
+    "@stacksjs/development": "0.57.2"
   },
   "scripts": {
     "build": "unbuild",