@mundoit-lib/plugin-vue-event 1.0.0 → 1.0.2

package/dist/eventBus.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var mitt = require('mitt');
+
+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;
+    }
+  };
+};
+
+exports.eventBus = eventBus;
+exports.useEventBus = useEventBus;

package/dist/eventBus.d.cts

@@ -0,0 +1,15 @@
+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]>;
+}
+declare const useEventBus: () => EventBusInstance;
+
+export { type EventBusEvents, type EventBusInstance, eventBus, useEventBus };

package/dist/eventBus.d.ts

@@ -0,0 +1,15 @@
+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]>;
+}
+declare const useEventBus: () => EventBusInstance;
+
+export { type EventBusEvents, type EventBusInstance, eventBus, useEventBus };

package/dist/eventBus.js

@@ -0,0 +1,33 @@
+import mitt from 'mitt';
+
+// 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;
+    }
+  };
+};
+
+export { eventBus, useEventBus };

package/dist/index.cjs

@@ -0,0 +1,91 @@
+'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;

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+export { EventBusEvents, EventBusInstance, eventBus, useEventBus } from './eventBus.cjs';
+export { default as eventsPlugin } from './plugin.cjs';
+import 'mitt';
+import 'vue-demi';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { EventBusEvents, EventBusInstance, eventBus, useEventBus } from './eventBus.js';
+export { default as eventsPlugin } from './plugin.js';
+import 'mitt';
+import 'vue-demi';

package/dist/index.js

@@ -0,0 +1,83 @@
+import mitt from 'mitt';
+import { isVue3, isVue2 } from 'vue-demi';
+
+// 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;
+    }
+  };
+};
+function plugin(VueOrApp) {
+  const bus = useEventBus();
+  if (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 (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;
+
+export { eventBus, plugin_default as eventsPlugin, useEventBus };

package/dist/plugin.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var vueDemi = require('vue-demi');
+var mitt = require('mitt');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var mitt__default = /*#__PURE__*/_interopDefault(mitt);
+
+// src/plugin.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;
+    }
+  };
+};
+
+// src/plugin.ts
+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;
+
+module.exports = plugin_default;

package/dist/plugin.d.cts

@@ -0,0 +1,10 @@
+import { App } from 'vue-demi';
+
+interface Vue2Constructor {
+    prototype: any;
+    mixin: (options: any) => void;
+}
+declare function plugin(app: App): void;
+declare function plugin(Vue: Vue2Constructor): void;
+
+export { plugin as default };

package/dist/plugin.d.ts

@@ -0,0 +1,10 @@
+import { App } from 'vue-demi';
+
+interface Vue2Constructor {
+    prototype: any;
+    mixin: (options: any) => void;
+}
+declare function plugin(app: App): void;
+declare function plugin(Vue: Vue2Constructor): void;
+
+export { plugin as default };

package/{src/index.js → dist/plugin.js}

@@ -1,17 +1,12 @@
+import { isVue3, isVue2 } from 'vue-demi';
 import mitt from 'mitt';
 
-function plugin(VueOrApp) {
-  let isVue3 = false;
-
-  if (typeof VueOrApp.version === 'string' && VueOrApp.version.startsWith('3.')) {
-    isVue3 = true;
-  }
-
-  const eventBus = mitt();
-
-  const bus = {
+// src/plugin.ts
+var eventBus = mitt();
+var useEventBus = () => {
+  return {
     emit(event, ...args) {
-       eventBus.emit(event, args);
+      eventBus.emit(event, args);
     },
     on(event, callback) {
       const listener = (args) => callback(...args);
@@ -24,61 +19,67 @@ function plugin(VueOrApp) {
     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;
+    }
   };
+};
 
+// src/plugin.ts
+function plugin(VueOrApp) {
+  const bus = useEventBus();
   if (isVue3) {
-    VueOrApp.config.globalProperties.$events = bus;
-
-    VueOrApp.mixin({
+    const app = VueOrApp;
+    app.config.globalProperties.$events = bus;
+    app.mixin({
       beforeCreate() {
-        if (typeof this.$options.events !== 'object') return;
-
+        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 {
-    Object.defineProperty(VueOrApp.prototype, '$events', {
+  } else if (isVue2) {
+    const Vue = VueOrApp;
+    Object.defineProperty(Vue.prototype, "$events", {
       get() {
         return bus;
-      },
+      }
     });
-
-    VueOrApp.mixin({
+    Vue.mixin({
       beforeCreate() {
-        if (typeof this.$options.events !== 'object') return;
-
+        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;
 
-export default plugin;
+export { plugin_default as default };

package/package.json

@@ -1,17 +1,33 @@
 {
   "name": "@mundoit-lib/plugin-vue-event",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Vue 3 plugin to handle global events between components, inspired by vue-events. This plugin provides a simple and efficient event bus system, allowing to emit, listen and unregister events in an intuitive way. Compatible with Vue 2 and Vue 3.",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/@mundoit-lib/plugin-vue-event.umd.js",
-  "module": "./dist/@mundoit-lib/plugin-vue-event.es.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/@mundoit-lib/plugin-vue-event.es.js",
-      "require": "./dist/@mundoit-lib/plugin-vue-event.umd.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js",
+      "require": "./dist/plugin.cjs"
+    },
+    "./eventBus": {
+      "types": "./dist/eventBus.d.ts",
+      "import": "./dist/eventBus.js",
+      "require": "./dist/eventBus.cjs"
     }
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/mundoit-lib/plugin-vue-event"
@@ -39,18 +55,27 @@
   ],
   "author": "@mundoit-lib",
   "scripts": {
-    "dev": "vite build --watch",
-    "build": "vite build",
-    "preview": "vite preview"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsup",
+    "clean": "rm -rf dist && rm -rf node_modules",
+    "postinstall": "npx vue-demi-fix"
   },
   "dependencies": {
-    "mitt": "^3.0.1"
+    "mitt": "^3.0.1",
+    "vue-demi": "0.14.10"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "vite": "^5.4.11"
+    "@types/node": "^22.19.1",
+    "tsup": "^8.5.1",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@vue/composition-api": "^1.0.0-rc.1",
+    "vue": "^2.0.0 || >=3.0.0"
   },
-  "optionalDependencies": {
-    "@rollup/rollup-linux-x64-gnu": "4.27.3"
+  "peerDependenciesMeta": {
+    "@vue/composition-api": {
+      "optional": true
+    }
   }
 }

package/src/eventBus.ts

@@ -0,0 +1,72 @@
+import mitt, { type Emitter, type EventType, type Handler } from 'mitt';
+
+// Define el tipo de eventos de tu aplicación
+// Puedes extender este tipo según tus necesidades
+export type EventBusEvents = Record<EventType, any>;
+
+// Tipos para los listeners
+type EventListener<T = any> = (args: T) => void;
+type UnwrappedHandler<T = any> = (...args: any[]) => T;
+
+// Exportamos una única instancia del event bus
+export const eventBus: Emitter<EventBusEvents> = mitt<EventBusEvents>();
+
+// Interface para el retorno de useEventBus
+export 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]>;
+}
+
+// Exportamos helpers para usar en composables o archivos JS/TS
+export const useEventBus = (): EventBusInstance => {
+  return {
+    emit<K extends keyof EventBusEvents>(event: K, ...args: any[]): void {
+      eventBus.emit(event, args);
+    },
+    
+    on<K extends keyof EventBusEvents>(
+      event: K,
+      callback: UnwrappedHandler
+    ): Handler<EventBusEvents[K]> {
+      const listener: Handler<EventBusEvents[K]> = (args: any) => callback(...args);
+      eventBus.on(event, listener);
+      return listener;
+    },
+    
+    fire<K extends keyof EventBusEvents>(event: K, ...args: any[]): void {
+      eventBus.emit(event, args);
+    },
+    
+    off<K extends keyof EventBusEvents>(
+      event: K,
+      listener: Handler<EventBusEvents[K]>
+    ): void {
+      eventBus.off(event, listener);
+    },
+    
+    once<K extends keyof EventBusEvents>(
+      event: K,
+      callback: UnwrappedHandler
+    ): Handler<EventBusEvents[K]> {
+      const listener: Handler<EventBusEvents[K]> = (args: any) => callback(...args);
+      const wrappedListener: Handler<EventBusEvents[K]> = (args: any) => {
+        listener(args);
+        eventBus.off(event, wrappedListener);
+      };
+      eventBus.on(event, wrappedListener);
+      return wrappedListener;
+    }
+  };
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { eventBus, useEventBus } from './eventBus';
+export { default as eventsPlugin } from './plugin';
+export type { EventBusInstance, EventBusEvents } from './eventBus';

package/src/plugin.ts

@@ -0,0 +1,91 @@
+import { isVue2, isVue3 } from 'vue-demi';
+import type { App, ComponentOptions } from 'vue-demi';
+import { useEventBus, type EventBusInstance } from './eventBus';
+
+// Tipos para Vue 2
+interface Vue2Constructor {
+  prototype: any;
+  mixin: (options: any) => void;
+}
+
+// Tipos para las opciones de componentes extendidas
+interface ComponentWithEvents extends ComponentOptions {
+  events?: Record<string, (...args: any[]) => void>;
+}
+
+// Tipo interno para los listeners almacenados
+interface StoredListener {
+  event: string;
+  listener: any;
+}
+
+// Extensión de tipos para Vue 2
+interface Vue2Instance {
+  $options: ComponentWithEvents;
+  _eventListeners?: StoredListener[];
+  $events?: EventBusInstance;
+}
+// Sobrecarga de tipos para el plugin
+function plugin(app: App): void;
+function plugin(Vue: Vue2Constructor): void;
+function plugin(VueOrApp: App | Vue2Constructor): void {
+  const bus = useEventBus();
+
+  if (isVue3) {
+    // Vue 3
+    const app = VueOrApp as App;
+    app.config.globalProperties.$events = bus;
+    
+    app.mixin({
+      beforeCreate(this: any) {
+        if (typeof this.$options.events !== 'object') return;
+        this._eventListeners = [] as StoredListener[];
+        
+        for (const [event, handler] of Object.entries(this.$options.events)) {
+          // @ts-ignore
+          const boundHandler = handler.bind(this);
+          const listener = bus.on(event, boundHandler);
+          this._eventListeners.push({ event, listener });
+        }
+      },
+      beforeUnmount(this: any) {
+        if (!this._eventListeners) return;
+        
+        for (const { event, listener } of this._eventListeners as StoredListener[]) {
+          bus.off(event, listener);
+        }
+      },
+    });
+  } else if (isVue2) {
+    // Vue 2
+    const Vue = VueOrApp as Vue2Constructor;
+    
+    Object.defineProperty(Vue.prototype, '$events', {
+      get() {
+        return bus;
+      },
+    });
+    
+    Vue.mixin({
+      beforeCreate(this: Vue2Instance) {
+        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(this: Vue2Instance) {
+        if (!this._eventListeners) return;
+        
+        for (const { event, listener } of this._eventListeners) {
+          bus.off(event, listener);
+        }
+      },
+    });
+  }
+}
+
+export default plugin;

package/.editorconfig

@@ -1,12 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = false
-insert_final_newline = false

package/.vscode/setting.json

@@ -1,43 +0,0 @@
-{
-  "[javascript]": {
-    "editor.defaultFormatter": "biomejs.biome"
-},
-  "biomejs.biome": {
-    "formatOnSave": true,
-    "formatOnPaste": true,
-    "formatOnType": true,
-    "formatOnSaveTimeout": 5000,
-    "formatOnPasteTimeout": 5000,
-    "formatOnTypeTimeout": 5000,
-    "formatOnSaveOptions": {
-      "tabSize": 2,
-      "useTabs": false,
-      "semi": true,
-      "singleQuote": false,
-      "trailingComma": "none",
-      "bracketSpacing": true,
-      "arrowParens": "always",
-      "printWidth": 80
-    },
-    "formatOnPasteOptions": {
-      "tabSize": 2,
-      "useTabs": false,
-      "semi": true,
-      "singleQuote": false,
-      "trailingComma": "none",
-      "bracketSpacing": true,
-      "arrowParens": "always",
-      "printWidth": 80
-    },
-    "formatOnTypeOptions": {
-      "tabSize": 2,
-      "useTabs": false,
-      "semi": true,
-      "singleQuote": false,
-      "trailingComma": "none",
-      "bracketSpacing": true,
-      "arrowParens": "always",
-      "printWidth": 80
-    }
-  }
-}

package/biome.json

@@ -1,32 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-	"vcs": {
-		"enabled": true,
-		"clientKind": "git",
-		"useIgnoreFile": false
-	},
-	"files": {
-		"ignoreUnknown": true,
-		"ignore": ["/node_modules", "/dist", "/.git", "/.github", "/.vscode"]
-	},
-	"formatter": {
-		"enabled": true,
-    "formatWithErrors": true,
-		"indentStyle": "space",
-    "useEditorconfig": true
-	},
-	"organizeImports": {
-		"enabled": true
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true
-		}
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "double"
-		}
-	}
-}

package/dist/@mundoit-lib/plugin-vue-event.es.js

@@ -1,73 +0,0 @@
-function c(n) {
-  return { all: n = n || /* @__PURE__ */ new Map(), on: function(o, i) {
-    var t = n.get(o);
-    t ? t.push(i) : n.set(o, [i]);
-  }, off: function(o, i) {
-    var t = n.get(o);
-    t && (i ? t.splice(t.indexOf(i) >>> 0, 1) : n.set(o, []));
-  }, emit: function(o, i) {
-    var t = n.get(o);
-    t && t.slice().map(function(e) {
-      e(i);
-    }), (t = n.get("*")) && t.slice().map(function(e) {
-      e(o, i);
-    });
-  } };
-}
-function v(n) {
-  let o = !1;
-  typeof n.version == "string" && n.version.startsWith("3.") && (o = !0);
-  const i = c(), t = {
-    emit(e, ...s) {
-      i.emit(e, s);
-    },
-    on(e, s) {
-      const r = (f) => s(...f);
-      return i.on(e, r), r;
-    },
-    fire(e, ...s) {
-      i.emit(e, s);
-    },
-    off(e, s) {
-      i.off(e, s);
-    }
-  };
-  o ? (n.config.globalProperties.$events = t, n.mixin({
-    beforeCreate() {
-      if (typeof this.$options.events == "object") {
-        this._eventListeners = [];
-        for (const [e, s] of Object.entries(this.$options.events)) {
-          const r = s.bind(this), f = t.on(e, r);
-          this._eventListeners.push({ event: e, listener: f });
-        }
-      }
-    },
-    beforeUnmount() {
-      if (this._eventListeners)
-        for (const { event: e, listener: s } of this._eventListeners)
-          t.off(e, s);
-    }
-  })) : (Object.defineProperty(n.prototype, "$events", {
-    get() {
-      return t;
-    }
-  }), n.mixin({
-    beforeCreate() {
-      if (typeof this.$options.events == "object") {
-        this._eventListeners = [];
-        for (const [e, s] of Object.entries(this.$options.events)) {
-          const r = s.bind(this), f = t.on(e, r);
-          this._eventListeners.push({ event: e, listener: f });
-        }
-      }
-    },
-    beforeDestroy() {
-      if (this._eventListeners)
-        for (const { event: e, listener: s } of this._eventListeners)
-          t.off(e, s);
-    }
-  }));
-}
-export {
-  v as default
-};

package/dist/@mundoit-lib/plugin-vue-event.umd.js

@@ -1 +0,0 @@
-(function(f,u){typeof exports=="object"&&typeof module<"u"?module.exports=u():typeof define=="function"&&define.amd?define(u):(f=typeof globalThis<"u"?globalThis:f||self,f["@mundoit-lib/plugin-vue-event"]=u())})(this,function(){"use strict";function f(n){return{all:n=n||new Map,on:function(o,s){var t=n.get(o);t?t.push(s):n.set(o,[s])},off:function(o,s){var t=n.get(o);t&&(s?t.splice(t.indexOf(s)>>>0,1):n.set(o,[]))},emit:function(o,s){var t=n.get(o);t&&t.slice().map(function(e){e(s)}),(t=n.get("*"))&&t.slice().map(function(e){e(o,s)})}}}function u(n){let o=!1;typeof n.version=="string"&&n.version.startsWith("3.")&&(o=!0);const s=f(),t={emit(e,...i){s.emit(e,i)},on(e,i){const r=c=>i(...c);return s.on(e,r),r},fire(e,...i){s.emit(e,i)},off(e,i){s.off(e,i)}};o?(n.config.globalProperties.$events=t,n.mixin({beforeCreate(){if(typeof this.$options.events=="object"){this._eventListeners=[];for(const[e,i]of Object.entries(this.$options.events)){const r=i.bind(this),c=t.on(e,r);this._eventListeners.push({event:e,listener:c})}}},beforeUnmount(){if(this._eventListeners)for(const{event:e,listener:i}of this._eventListeners)t.off(e,i)}})):(Object.defineProperty(n.prototype,"$events",{get(){return t}}),n.mixin({beforeCreate(){if(typeof this.$options.events=="object"){this._eventListeners=[];for(const[e,i]of Object.entries(this.$options.events)){const r=i.bind(this),c=t.on(e,r);this._eventListeners.push({event:e,listener:c})}}},beforeDestroy(){if(this._eventListeners)for(const{event:e,listener:i}of this._eventListeners)t.off(e,i)}}))}return u});

package/vite.config.js

@@ -1,15 +0,0 @@
-import path from 'node:path';
-import { defineConfig } from 'vite';
-
-const packagename = '@mundoit-lib/plugin-vue-event';
-
-export default defineConfig({
-  build: {
-    lib: {
-      entry: path.resolve(__dirname, 'src/index.js'),
-      formats: ['es', 'umd'],
-      name: packagename,
-      fileName: (format) => `${packagename}.${format}.js`,
-    },
-  },
-});