@mundoit-lib/plugin-vue-event 1.0.1 → 2.0.2

package/README.md

@@ -0,0 +1,121 @@
+# @mundoit-lib/plugin-vue-event
+
+Bus de eventos global para Vue 3, sobre [mitt](https://github.com/developit/mitt). Expone `$events`, la opción de componente `events:` y el composable `useEvents()`, que desregistra solo al desmontar. Los eventos se pueden tipar por module augmentation.
+
+## Instalación
+
+```bash
+pnpm add @mundoit-lib/plugin-vue-event
+```
+
+```ts
+import { createApp } from 'vue';
+import { eventsPlugin } from '@mundoit-lib/plugin-vue-event';
+
+createApp(App).use(eventsPlugin).mount('#app');
+```
+
+`install` hace tres cosas:
+
+- `app.config.globalProperties.$events = bus`;
+- `app.provide('mundoitEvents', bus)` (la clave está exportada como `EVENTS_KEY`);
+- un mixin global que registra la opción `events:` de cada componente.
+
+Por defecto usa `eventBus`, el bus compartido del paquete. Para usar uno propio:
+
+```ts
+import { createEventBus, eventsPlugin } from '@mundoit-lib/plugin-vue-event';
+
+const bus = createEventBus();
+app.use(eventsPlugin, { bus });
+```
+
+## API del bus
+
+```ts
+bus.emit('saved', id, data);              // los listeners reciben (id, data)
+const fn = bus.on('saved', (id, data) => {});
+bus.once('saved', (id) => {});
+bus.off('saved', fn);                     // saca ese listener
+bus.off('saved');                         // saca todos los de 'saved'
+```
+
+- `on` y `once` devuelven el mismo listener que reciben, así que `off` funciona con el handle o con la función original.
+- `createEventBus()` crea buses independientes; `eventBus` es el que se comparte por defecto.
+- `bus.rawBus` es el emitter de mitt. Ojo: cada evento viaja con **un solo payload, el array de argumentos** (`rawBus.on('saved', ([id, data]) => {})`). Usarlo sólo si hace falta algo de mitt que el bus no expone (por ejemplo `rawBus.all`).
+
+## Opción `events:` (Options API)
+
+```ts
+export default {
+  events: {
+    'loaded-user'(user) {
+      this.user = user; // `this` es el componente
+    }
+  },
+  methods: {
+    save() {
+      this.$events.emit('saved', this.id);
+    }
+  }
+};
+```
+
+Los listeners se registran en `beforeCreate` y se desregistran en `beforeUnmount`.
+
+## `useEvents()` (Composition API)
+
+```ts
+import { useEvents } from '@mundoit-lib/plugin-vue-event';
+
+const events = useEvents();
+events.on('loaded-user', (user) => { /* … */ });   // se desregistra solo al desmontar
+events.once('ready', () => { /* … */ });
+events.emit('saved', id);
+```
+
+- Dentro de un `setup` usa el bus de la app (el que se pasó a `install`); también se le puede pasar uno: `useEvents(bus)`.
+- Lo que se registra con `on`/`once` se desregistra en `onBeforeUnmount`. `off` lo saca antes.
+- Fuera de un componente se comporta como el bus y no desregistra nada solo.
+
+`useEventBus()` devuelve el bus de la app (o `eventBus` fuera de un componente) sin auto-desregistro, como en 1.x.
+
+## Tipado
+
+Por defecto cualquier nombre de evento acepta cualquier argumento. Para tipar los de la app, declarar `MundoitEvents` (en un `.d.ts` o en cualquier archivo incluido en el `tsconfig`):
+
+```ts
+import type { User } from '@/types';
+
+declare module '@mundoit-lib/plugin-vue-event' {
+  interface MundoitEvents {
+    'loaded-user': [user: User];
+    saved: [id: number, data?: unknown];
+  }
+}
+```
+
+Con eso `emit`, `on`, `once`, `off` y `$events` controlan los argumentos de esos eventos y los autocompletan. Los eventos no declarados siguen siendo `any`.
+
+## Deprecado (se elimina en 3.0)
+
+Siguen andando en 2.x por compatibilidad con 1.x y se sacan en la 3.0.
+
+| Qué | Reemplazo |
+|---|---|
+| `fire()` (`$events.fire`, `eventBus.fire`) | `emit()` |
+| Tipos `EventBusInstance`, `EventBusEvents` | `EventBus`, `MundoitEvents` |
+
+## Migración 1.x → 2.0
+
+| 1.x | 2.0 |
+|---|---|
+| Vue 2 y Vue 3 | **Sólo Vue 3** (`vue ^3.3`). En Vue 2 quedarse en 1.x. |
+| `$events.fire(...)` | Sigue andando, pero está deprecado (se elimina en 3.0): usar `$events.emit(...)`. En desarrollo avisa una vez por consola. |
+| `useEventBus()` | Sigue igual. Para componentes, mejor `useEvents()`, que desregistra solo. |
+| `off(evento, handle)` con el valor que devolvía `on` | Igual, y además acepta la función original o sólo el evento. |
+| `EventBusInstance`, `EventBusEvents` | Deprecados (se eliminan en 3.0): usar `EventBus` y `MundoitEvents`. |
+| `eventBus` era el emitter de mitt | `eventBus` es el bus (`emit`/`on`/…); el emitter de mitt está en `eventBus.rawBus`. |
+| Dependencias de compatibilidad con Vue 2 | Ya no hacen falta: se pueden sacar de la app si nadie más los usa. |
+
+Para una app en Vue 3 que usa `events:` y `$events`, actualizar es sólo subir la versión.

package/dist/eventBus.cjs

@@ -1,40 +1,118 @@
-'use strict';
-
-var mitt = require('mitt');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-var mitt__default = /*#__PURE__*/_interopDefault(mitt);
+//#endregion
+let mitt = require("mitt");
+mitt = __toESM(mitt, 1);
+let vue = require("vue");
 
-// src/eventBus.ts
-var eventBus = mitt__default.default();
-var useEventBus = () => {
-  return {
-    emit(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    on(event, callback) {
-      const listener = (args) => callback(...args);
-      eventBus.on(event, listener);
-      return listener;
-    },
-    fire(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    off(event, listener) {
-      eventBus.off(event, listener);
-    },
-    once(event, callback) {
-      const listener = (args) => callback(...args);
-      const wrappedListener = (args) => {
-        listener(args);
-        eventBus.off(event, wrappedListener);
-      };
-      eventBus.on(event, wrappedListener);
-      return wrappedListener;
-    }
-  };
-};
+//#region src/eventBus.ts
+let fireWarned = false;
+function isDev() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+}
+/** Crea un bus de eventos independiente. */
+function createEventBus() {
+	const rawBus = (0, mitt.default)();
+	const registry = /* @__PURE__ */ new Map();
+	function register(event, listener, handler) {
+		let byListener = registry.get(event);
+		if (!byListener) {
+			byListener = /* @__PURE__ */ new Map();
+			registry.set(event, byListener);
+		}
+		const handlers = byListener.get(listener);
+		if (handlers) handlers.push(handler);
+		else byListener.set(listener, [handler]);
+		rawBus.on(event, handler);
+	}
+	function unregister(event, listener, handler) {
+		const byListener = registry.get(event);
+		const handlers = byListener?.get(listener);
+		if (!byListener || !handlers) return;
+		const toRemove = handler ? handlers.filter((h) => h === handler) : handlers;
+		for (const h of toRemove) rawBus.off(event, h);
+		const rest = handler ? handlers.filter((h) => h !== handler) : [];
+		if (rest.length) byListener.set(listener, rest);
+		else byListener.delete(listener);
+		if (!byListener.size) registry.delete(event);
+	}
+	const bus = {
+		rawBus,
+		emit(event, ...args) {
+			rawBus.emit(event, args);
+		},
+		on(event, listener) {
+			register(event, listener, (args) => listener(...args ?? []));
+			return listener;
+		},
+		once(event, listener) {
+			const handler = (args) => {
+				unregister(event, listener, handler);
+				listener(...args ?? []);
+			};
+			register(event, listener, handler);
+			return listener;
+		},
+		off(event, listener) {
+			if (listener) unregister(event, listener);
+			else {
+				rawBus.off(event);
+				registry.delete(event);
+			}
+		},
+		fire(event, ...args) {
+			if (!fireWarned && isDev()) {
+				fireWarned = true;
+				console.warn("[@mundoit-lib/plugin-vue-event] `fire` está deprecado y se elimina en 3.0, usar `emit`.");
+			}
+			bus.emit(event, ...args);
+		}
+	};
+	return bus;
+}
+/** Bus por defecto: el que usa el plugin si no se le pasa otro. */
+const eventBus = createEventBus();
+/** Clave con la que el plugin hace `app.provide` del bus. */
+const EVENTS_KEY = "mundoitEvents";
+/**
+* Devuelve el bus de la app (el que se pasó a `install`) si se llama dentro de un `setup`,
+* o el bus por defecto si no. No desregistra nada solo: para eso está `useEvents`.
+*/
+function useEventBus() {
+	return (0, vue.getCurrentInstance)() ? (0, vue.inject)(EVENTS_KEY, eventBus) : eventBus;
+}
 
+//#endregion
+exports.EVENTS_KEY = EVENTS_KEY;
+exports.createEventBus = createEventBus;
 exports.eventBus = eventBus;
-exports.useEventBus = useEventBus;
+exports.useEventBus = useEventBus;

package/dist/eventBus.d.cts

@@ -1,15 +1,54 @@
-import { EventType, Emitter, Handler } from 'mitt';
-
-type EventBusEvents = Record<EventType, any>;
-type UnwrappedHandler<T = any> = (...args: any[]) => T;
-declare const eventBus: Emitter<EventBusEvents>;
-interface EventBusInstance {
-    emit<K extends keyof EventBusEvents>(event: K, ...args: any[]): void;
-    on<K extends keyof EventBusEvents>(event: K, callback: UnwrappedHandler): Handler<EventBusEvents[K]>;
-    fire<K extends keyof EventBusEvents>(event: K, ...args: any[]): void;
-    off<K extends keyof EventBusEvents>(event: K, listener: Handler<EventBusEvents[K]>): void;
-    once<K extends keyof EventBusEvents>(event: K, callback: UnwrappedHandler): Handler<EventBusEvents[K]>;
+import { Emitter, EventType } from "mitt";
+//#region src/eventBus.d.ts
+/**
+ * Mapa de eventos de la app: nombre → tupla de argumentos.
+ * Se extiende por module augmentation:
+ *
+ * ```ts
+ * declare module '@mundoit-lib/plugin-vue-event' {
+ *   interface MundoitEvents {
+ *     'loaded-user': [user: User];
+ *   }
+ * }
+ * ```
+ *
+ * Los eventos que no están declarados siguen aceptando cualquier argumento.
+ */
+export interface MundoitEvents {}
+/** Nombre de evento: los declarados en `MundoitEvents` (con autocompletado) o cualquier string. */
+export type EventName = keyof MundoitEvents | (string & Record<never, never>);
+/** Argumentos de un evento: la tupla declarada en `MundoitEvents`, o `any[]` si no está declarado. */
+export type EventArgs<K extends EventName> = K extends keyof MundoitEvents ? MundoitEvents[K] extends unknown[] ? MundoitEvents[K] : [MundoitEvents[K]] : any[];
+export type EventListener<K extends EventName = EventName> = (...args: EventArgs<K>) => void;
+/** Emitter crudo de mitt: cada evento viaja con un único payload, el array de argumentos. */
+export type RawEventBus = Emitter<Record<EventType, unknown[]>>;
+export interface EventBus {
+  /** Emite `event` con los argumentos dados; cada listener los recibe tal cual (`on('x', (a, b) => …)`). */
+  emit<K extends EventName>(event: K, ...args: EventArgs<K>): void;
+  /** Registra `listener` y lo devuelve, para pasarlo después a `off`. */
+  on<K extends EventName>(event: K, listener: EventListener<K>): EventListener<K>;
+  /** Como `on`, pero se desregistra solo después de la primera vez. */
+  once<K extends EventName>(event: K, listener: EventListener<K>): EventListener<K>;
+  /** Desregistra `listener` de `event`; sin `listener`, desregistra todos los de `event`. */
+  off<K extends EventName>(event: K, listener?: EventListener<K>): void;
+  /** @deprecated Se elimina en 3.0. Usar `emit`. */
+  fire<K extends EventName>(event: K, ...args: EventArgs<K>): void;
+  /** El emitter de mitt por debajo. Ojo: el payload de cada evento es el array de argumentos. */
+  readonly rawBus: RawEventBus;
 }
-declare const useEventBus: () => EventBusInstance;
-
-export { type EventBusEvents, type EventBusInstance, eventBus, useEventBus };
+/** @deprecated Se elimina en 3.0. Nombre de 1.x, usar `EventBus`. */
+export type EventBusInstance = EventBus;
+/** @deprecated Se elimina en 3.0. Tipo de 1.x, usar `MundoitEvents`. */
+export type EventBusEvents = Record<EventType, any>;
+/** Crea un bus de eventos independiente. */
+export declare function createEventBus(): EventBus;
+/** Bus por defecto: el que usa el plugin si no se le pasa otro. */
+export declare const eventBus: EventBus;
+/** Clave con la que el plugin hace `app.provide` del bus. */
+export declare const EVENTS_KEY = "mundoitEvents";
+/**
+ * Devuelve el bus de la app (el que se pasó a `install`) si se llama dentro de un `setup`,
+ * o el bus por defecto si no. No desregistra nada solo: para eso está `useEvents`.
+ */
+export declare function useEventBus(): EventBus;
+//#endregion

package/dist/eventBus.d.ts

@@ -1,15 +1,54 @@
-import { EventType, Emitter, Handler } from 'mitt';
-
-type EventBusEvents = Record<EventType, any>;
-type UnwrappedHandler<T = any> = (...args: any[]) => T;
-declare const eventBus: Emitter<EventBusEvents>;
-interface EventBusInstance {
-    emit<K extends keyof EventBusEvents>(event: K, ...args: any[]): void;
-    on<K extends keyof EventBusEvents>(event: K, callback: UnwrappedHandler): Handler<EventBusEvents[K]>;
-    fire<K extends keyof EventBusEvents>(event: K, ...args: any[]): void;
-    off<K extends keyof EventBusEvents>(event: K, listener: Handler<EventBusEvents[K]>): void;
-    once<K extends keyof EventBusEvents>(event: K, callback: UnwrappedHandler): Handler<EventBusEvents[K]>;
+import { Emitter, EventType } from "mitt";
+//#region src/eventBus.d.ts
+/**
+ * Mapa de eventos de la app: nombre → tupla de argumentos.
+ * Se extiende por module augmentation:
+ *
+ * ```ts
+ * declare module '@mundoit-lib/plugin-vue-event' {
+ *   interface MundoitEvents {
+ *     'loaded-user': [user: User];
+ *   }
+ * }
+ * ```
+ *
+ * Los eventos que no están declarados siguen aceptando cualquier argumento.
+ */
+export interface MundoitEvents {}
+/** Nombre de evento: los declarados en `MundoitEvents` (con autocompletado) o cualquier string. */
+export type EventName = keyof MundoitEvents | (string & Record<never, never>);
+/** Argumentos de un evento: la tupla declarada en `MundoitEvents`, o `any[]` si no está declarado. */
+export type EventArgs<K extends EventName> = K extends keyof MundoitEvents ? MundoitEvents[K] extends unknown[] ? MundoitEvents[K] : [MundoitEvents[K]] : any[];
+export type EventListener<K extends EventName = EventName> = (...args: EventArgs<K>) => void;
+/** Emitter crudo de mitt: cada evento viaja con un único payload, el array de argumentos. */
+export type RawEventBus = Emitter<Record<EventType, unknown[]>>;
+export interface EventBus {
+  /** Emite `event` con los argumentos dados; cada listener los recibe tal cual (`on('x', (a, b) => …)`). */
+  emit<K extends EventName>(event: K, ...args: EventArgs<K>): void;
+  /** Registra `listener` y lo devuelve, para pasarlo después a `off`. */
+  on<K extends EventName>(event: K, listener: EventListener<K>): EventListener<K>;
+  /** Como `on`, pero se desregistra solo después de la primera vez. */
+  once<K extends EventName>(event: K, listener: EventListener<K>): EventListener<K>;
+  /** Desregistra `listener` de `event`; sin `listener`, desregistra todos los de `event`. */
+  off<K extends EventName>(event: K, listener?: EventListener<K>): void;
+  /** @deprecated Se elimina en 3.0. Usar `emit`. */
+  fire<K extends EventName>(event: K, ...args: EventArgs<K>): void;
+  /** El emitter de mitt por debajo. Ojo: el payload de cada evento es el array de argumentos. */
+  readonly rawBus: RawEventBus;
 }
-declare const useEventBus: () => EventBusInstance;
-
-export { type EventBusEvents, type EventBusInstance, eventBus, useEventBus };
+/** @deprecated Se elimina en 3.0. Nombre de 1.x, usar `EventBus`. */
+export type EventBusInstance = EventBus;
+/** @deprecated Se elimina en 3.0. Tipo de 1.x, usar `MundoitEvents`. */
+export type EventBusEvents = Record<EventType, any>;
+/** Crea un bus de eventos independiente. */
+export declare function createEventBus(): EventBus;
+/** Bus por defecto: el que usa el plugin si no se le pasa otro. */
+export declare const eventBus: EventBus;
+/** Clave con la que el plugin hace `app.provide` del bus. */
+export declare const EVENTS_KEY = "mundoitEvents";
+/**
+ * Devuelve el bus de la app (el que se pasó a `install`) si se llama dentro de un `setup`,
+ * o el bus por defecto si no. No desregistra nada solo: para eso está `useEvents`.
+ */
+export declare function useEventBus(): EventBus;
+//#endregion

package/dist/eventBus.js

@@ -1,33 +1,86 @@
-import mitt from 'mitt';
+import mitt from "mitt";
+import { getCurrentInstance, inject } from "vue";
 
-// src/eventBus.ts
-var eventBus = mitt();
-var useEventBus = () => {
-  return {
-    emit(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    on(event, callback) {
-      const listener = (args) => callback(...args);
-      eventBus.on(event, listener);
-      return listener;
-    },
-    fire(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    off(event, listener) {
-      eventBus.off(event, listener);
-    },
-    once(event, callback) {
-      const listener = (args) => callback(...args);
-      const wrappedListener = (args) => {
-        listener(args);
-        eventBus.off(event, wrappedListener);
-      };
-      eventBus.on(event, wrappedListener);
-      return wrappedListener;
-    }
-  };
-};
+//#region src/eventBus.ts
+let fireWarned = false;
+function isDev() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+}
+/** Crea un bus de eventos independiente. */
+function createEventBus() {
+	const rawBus = mitt();
+	const registry = /* @__PURE__ */ new Map();
+	function register(event, listener, handler) {
+		let byListener = registry.get(event);
+		if (!byListener) {
+			byListener = /* @__PURE__ */ new Map();
+			registry.set(event, byListener);
+		}
+		const handlers = byListener.get(listener);
+		if (handlers) handlers.push(handler);
+		else byListener.set(listener, [handler]);
+		rawBus.on(event, handler);
+	}
+	function unregister(event, listener, handler) {
+		const byListener = registry.get(event);
+		const handlers = byListener?.get(listener);
+		if (!byListener || !handlers) return;
+		const toRemove = handler ? handlers.filter((h) => h === handler) : handlers;
+		for (const h of toRemove) rawBus.off(event, h);
+		const rest = handler ? handlers.filter((h) => h !== handler) : [];
+		if (rest.length) byListener.set(listener, rest);
+		else byListener.delete(listener);
+		if (!byListener.size) registry.delete(event);
+	}
+	const bus = {
+		rawBus,
+		emit(event, ...args) {
+			rawBus.emit(event, args);
+		},
+		on(event, listener) {
+			register(event, listener, (args) => listener(...args ?? []));
+			return listener;
+		},
+		once(event, listener) {
+			const handler = (args) => {
+				unregister(event, listener, handler);
+				listener(...args ?? []);
+			};
+			register(event, listener, handler);
+			return listener;
+		},
+		off(event, listener) {
+			if (listener) unregister(event, listener);
+			else {
+				rawBus.off(event);
+				registry.delete(event);
+			}
+		},
+		fire(event, ...args) {
+			if (!fireWarned && isDev()) {
+				fireWarned = true;
+				console.warn("[@mundoit-lib/plugin-vue-event] `fire` está deprecado y se elimina en 3.0, usar `emit`.");
+			}
+			bus.emit(event, ...args);
+		}
+	};
+	return bus;
+}
+/** Bus por defecto: el que usa el plugin si no se le pasa otro. */
+const eventBus = createEventBus();
+/** Clave con la que el plugin hace `app.provide` del bus. */
+const EVENTS_KEY = "mundoitEvents";
+/**
+* Devuelve el bus de la app (el que se pasó a `install`) si se llama dentro de un `setup`,
+* o el bus por defecto si no. No desregistra nada solo: para eso está `useEvents`.
+*/
+function useEventBus() {
+	return getCurrentInstance() ? inject(EVENTS_KEY, eventBus) : eventBus;
+}
 
-export { eventBus, useEventBus };
+//#endregion
+export { EVENTS_KEY, createEventBus, eventBus, useEventBus };

package/dist/index.cjs

@@ -1,91 +1,11 @@
-'use strict';
-
-var mitt = require('mitt');
-var vueDemi = require('vue-demi');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var mitt__default = /*#__PURE__*/_interopDefault(mitt);
-
-// src/eventBus.ts
-var eventBus = mitt__default.default();
-var useEventBus = () => {
-  return {
-    emit(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    on(event, callback) {
-      const listener = (args) => callback(...args);
-      eventBus.on(event, listener);
-      return listener;
-    },
-    fire(event, ...args) {
-      eventBus.emit(event, args);
-    },
-    off(event, listener) {
-      eventBus.off(event, listener);
-    },
-    once(event, callback) {
-      const listener = (args) => callback(...args);
-      const wrappedListener = (args) => {
-        listener(args);
-        eventBus.off(event, wrappedListener);
-      };
-      eventBus.on(event, wrappedListener);
-      return wrappedListener;
-    }
-  };
-};
-function plugin(VueOrApp) {
-  const bus = useEventBus();
-  if (vueDemi.isVue3) {
-    const app = VueOrApp;
-    app.config.globalProperties.$events = bus;
-    app.mixin({
-      beforeCreate() {
-        if (typeof this.$options.events !== "object") return;
-        this._eventListeners = [];
-        for (const [event, handler] of Object.entries(this.$options.events)) {
-          const boundHandler = handler.bind(this);
-          const listener = bus.on(event, boundHandler);
-          this._eventListeners.push({ event, listener });
-        }
-      },
-      beforeUnmount() {
-        if (!this._eventListeners) return;
-        for (const { event, listener } of this._eventListeners) {
-          bus.off(event, listener);
-        }
-      }
-    });
-  } else if (vueDemi.isVue2) {
-    const Vue = VueOrApp;
-    Object.defineProperty(Vue.prototype, "$events", {
-      get() {
-        return bus;
-      }
-    });
-    Vue.mixin({
-      beforeCreate() {
-        if (typeof this.$options.events !== "object") return;
-        this._eventListeners = [];
-        for (const [event, handler] of Object.entries(this.$options.events)) {
-          const boundHandler = handler.bind(this);
-          const listener = bus.on(event, boundHandler);
-          this._eventListeners.push({ event, listener });
-        }
-      },
-      beforeDestroy() {
-        if (!this._eventListeners) return;
-        for (const { event, listener } of this._eventListeners) {
-          bus.off(event, listener);
-        }
-      }
-    });
-  }
-}
-var plugin_default = plugin;
-
-exports.eventBus = eventBus;
-exports.eventsPlugin = plugin_default;
-exports.useEventBus = useEventBus;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_eventBus = require('./eventBus.cjs');
+const require_plugin = require('./plugin.cjs');
+const require_useEvents = require('./useEvents.cjs');
+
+exports.EVENTS_KEY = require_eventBus.EVENTS_KEY;
+exports.createEventBus = require_eventBus.createEventBus;
+exports.eventBus = require_eventBus.eventBus;
+exports.eventsPlugin = require_plugin.default;
+exports.useEventBus = require_eventBus.useEventBus;
+exports.useEvents = require_useEvents.useEvents;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-export { EventBusEvents, EventBusInstance, eventBus, useEventBus } from './eventBus.cjs';
-export { default as eventsPlugin } from './plugin.cjs';
-import 'mitt';
-import 'vue-demi';
+import { EVENTS_KEY, EventArgs, EventBus, EventBusEvents, EventBusInstance, EventListener, EventName, MundoitEvents, RawEventBus, createEventBus, eventBus, useEventBus } from "./eventBus.cjs";
+import eventsPlugin, { EventsPluginOptions } from "./plugin.cjs";
+import { UseEventsReturn, useEvents } from "./useEvents.cjs";
+export { EVENTS_KEY, type EventArgs, type EventBus, type EventBusEvents, type EventBusInstance, type EventListener, type EventName, type EventsPluginOptions, type MundoitEvents, type RawEventBus, type UseEventsReturn, createEventBus, eventBus, eventsPlugin, useEventBus, useEvents };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { EventBusEvents, EventBusInstance, eventBus, useEventBus } from './eventBus.js';
-export { default as eventsPlugin } from './plugin.js';
-import 'mitt';
-import 'vue-demi';
+import { EVENTS_KEY, EventArgs, EventBus, EventBusEvents, EventBusInstance, EventListener, EventName, MundoitEvents, RawEventBus, createEventBus, eventBus, useEventBus } from "./eventBus.js";
+import eventsPlugin, { EventsPluginOptions } from "./plugin.js";
+import { UseEventsReturn, useEvents } from "./useEvents.js";
+export { EVENTS_KEY, type EventArgs, type EventBus, type EventBusEvents, type EventBusInstance, type EventListener, type EventName, type EventsPluginOptions, type MundoitEvents, type RawEventBus, type UseEventsReturn, createEventBus, eventBus, eventsPlugin, useEventBus, useEvents };