@stacksjs/events 0.57.4 → 0.58.20

package/README.md

@@ -9,7 +9,7 @@ Functional event emitting.
 ## 🤖 Usage
 
 ```bash
-pnpm i -D @stacksjs/events
+bun install -d @stacksjs/events
 ```
 
 Now, you can use it in your project:
@@ -35,12 +35,12 @@ listen('foo', onFoo) // listen
 off('foo', onFoo) // unlisten
 ```
 
-To view the full documentation, please visit [https://stacksjs.dev/events](https://stacksjs.dev/events).
+To view the full documentation, please visit [https://stacksjs.org/events](https://stacksjs.org/events).
 
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -59,7 +59,7 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 🙏🏼 Credits
 
@@ -73,4 +73,4 @@ Many thanks to the following core technologies & people who have contributed to
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,63 @@
+// @bun
+// src/index.ts
+function mitt(all) {
+  all = all || new Map;
+  return {
+    all,
+    on(type, handler) {
+      const handlers = all.get(type);
+      if (handlers)
+        handlers.push(handler);
+      else
+        all.set(type, [handler]);
+    },
+    off(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        if (handler)
+          handlers.splice(handlers.indexOf(handler) >>> 0, 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 = all.get("*");
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          if (evt)
+            return handler(type, evt);
+          console.error("No event provided");
+          return "No event provided";
+        });
+      }
+    }
+  };
+}
+var events = mitt;
+var emitter = events();
+var useEvent = emitter.emit.bind(emitter);
+var useEvents = events();
+var dispatch = emitter.emit.bind(emitter);
+var listen = emitter.on.bind(emitter);
+var off = emitter.off.bind(emitter);
+var all = emitter.all;
+export {
+  useEvents,
+  useEvent,
+  off,
+  mitt,
+  listen,
+  events,
+  dispatch,
+  mitt as default,
+  all
+};

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@stacksjs/events",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.20",
   "description": "Functional event emitting.",
   "author": "Chris Breuer",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/events#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/events#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/events"
+    "directory": "./storage/framework/core/src/events"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -25,28 +24,29 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
     }
   },
-  "module": "dist/index.mjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
-  "peerDependencies": {
-    "@stacksjs/alias": "0.57.4"
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.57.4"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+    "@stacksjs/development": "workspace:*"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,62 +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;
-    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.
- *
- * 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))
- * ```
- */
-declare const events: typeof mitt;
-declare const useEvent: {
-    <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: Emitter<Record<EventType, unknown>>;
-declare const dispatch: {
-    <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 EventType>(type: Key, handler: Handler<Record<EventType, unknown>[Key]>): void;
-    (type: '*', handler: WildcardHandler<Record<EventType, unknown>>): void;
-};
-declare const off: {
-    <Key extends EventType>(type: Key, handler?: Handler<Record<EventType, unknown>[Key]> | undefined): void;
-    (type: '*', handler: WildcardHandler<Record<EventType, unknown>>): void;
-};
-declare const all: EventHandlerMap<Record<EventType, unknown>>;
-export { useEvent, useEvents, dispatch, listen, all, off, events, mitt };

package/dist/index.mjs

@@ -1,71 +0,0 @@
-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;
-const useEvents = events();
-const dispatch = emitter.emit;
-const listen = emitter.on;
-const off = emitter.off;
-const all = emitter.all;
-export { useEvent, useEvents, dispatch, listen, all, off, events, mitt };