@chocolateish/lib-event 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+/**Event class
+ * contains the needed data to dispatch an event*/
+declare class E<Type, Target, Data> {
+    /**Any data to pass to the event listeners must be given in the constructor*/
+    constructor(type: Type, target: Target, data: Data);
+    /**Type of event */
+    readonly type: Type;
+    /**Reference to */
+    readonly target: Target;
+    /**Data of event */
+    readonly data: Data;
+}
+/**Function used to subscribe to event*/
+type ESubscriber<Type, Target, Data> = (event: E<Type, Target, Data>) => void;
+interface EventConsumer<Events extends object, Target> {
+    /**This add the subscriber to the event handler
+     * Returning true in subscriber will remove the subscriber from the event handler after call*/
+    on<K extends keyof Events>(eventName: K, subscriber: ESubscriber<K, Target, Events[K]>): typeof subscriber;
+    /**This removes the subscriber from the event handler*/
+    off<K extends keyof Events>(eventName: K, subscriber: ESubscriber<K, Target, Events[K]>): typeof subscriber;
+    /**Registers a proxy event handler that recieves all events from this event handler */
+    proxy_on(subscriber: ESubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    /**Deregisters a proxy event handler that recieves all events from this event handler */
+    proxy_off(subscriber: ESubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+}
+interface EventProducer<Events extends object, Target> extends EventConsumer<Events, Target> {
+    /**Override for target */
+    target: Target | undefined;
+    /**This dispatches the event, event data is frozen*/
+    emit<K extends keyof Events>(eventName: K, data: Events[K]): void;
+    /**This removes all listeners of a type from the event handler*/
+    clear<K extends keyof Events>(eventName: K): void;
+    /**Returns wether the type has listeners, true means it has at least a listener*/
+    in_use<K extends keyof Events>(eventName: K): boolean;
+    /**Returns wether the type has a specific listeners, true means it has that listener*/
+    has<K extends keyof Events>(eventName: K, subscriber: ESubscriber<K, Target, Events[K]>): boolean;
+    /**Returns the amount of listeners on that event*/
+    amount<K extends keyof Events>(eventName: K): number;
+    /**Generates a proxy function which can be registered with another handlers */
+    proxy_func(): ESubscriber<keyof Events, Target, Events[keyof Events]>;
+}
+declare class EventHandler<Events extends {
+    [key: string]: any;
+}, Target> implements EventProducer<Events, Target> {
+    #private;
+    target: Target;
+    constructor(target: Target);
+    on<K extends keyof Events>(event_name: K, subscriber: ESubscriber<K, Target, Events[K]>): typeof subscriber;
+    off<K extends keyof Events>(event_name: K, subscriber: ESubscriber<K, Target, Events[K]>): ESubscriber<K, Target, Events[K]>;
+    proxy_on(subscriber: ESubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    proxy_off(subscriber: ESubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    get consumer(): EventConsumer<Events, Target>;
+    emit<K extends keyof Events>(event_name: K, data: Events[K]): void;
+    clear<K extends keyof Events>(event_name: K): void;
+    in_use<K extends keyof Events>(event_name: K): boolean;
+    has<K extends keyof Events>(event_name: K, subscriber: ESubscriber<K, Target, Events[K]>): boolean;
+    amount<K extends keyof Events>(event_name: K): number;
+    proxy_func(): ESubscriber<keyof Events, Target, Events[keyof Events]>;
+    get producer(): EventProducer<Events, Target>;
+}
+
+/**Path to subevent */
+type SubPath = string[];
+/**Event class
+ * contains the needed data to dispatch an event*/
+declare class ESub<Type, Target, Data> {
+    /**Any data to pass to the event listeners must be given in the constructor*/
+    constructor(type: Type, target: Target, data: Data, sub?: SubPath);
+    /**Type of event */
+    readonly type: Type;
+    /**Reference to */
+    readonly target: Target;
+    /**Path to sub event */
+    readonly sub?: SubPath;
+    /**Data of event */
+    readonly data: Data;
+}
+/**Function used to subscribe to event*/
+type ESubSubscriber<Type, Target, Data> = (event: ESub<Type, Target, Data>) => void;
+interface EventSubConsumer<Events extends object, Target> {
+    /**This add the subscriber to the event handler
+     * Returning true in subscriber will remove the subscriber from the event handler after call*/
+    on<K extends keyof Events>(eventName: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): typeof subscriber;
+    /**This removes the subscriber from the event handler*/
+    off<K extends keyof Events>(eventName: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): typeof subscriber;
+    /**Registers a proxy event handler that recieves all events from this event handler */
+    proxy_on(subscriber: ESubSubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    /**Deregisters a proxy event handler that recieves all events from this event handler */
+    proxy_off(subscriber: ESubSubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+}
+interface EventSubProducer<Events extends object, Target> extends EventSubConsumer<Events, Target> {
+    /**Override for target */
+    target: Target | undefined;
+    /**This dispatches the event, event data is frozen*/
+    emit<K extends keyof Events>(eventName: K, data: Events[K], sub?: SubPath): void;
+    /**This removes all listeners of a type from the event handler*/
+    clear<K extends keyof Events>(eventName: K, sub?: SubPath, anyLevel?: boolean): void;
+    /**Returns wether the type has listeners, true means it has at least a listener*/
+    in_use<K extends keyof Events>(eventName: K, sub?: SubPath): boolean;
+    /**Returns wether the type has a specific listeners, true means it has that listener*/
+    has<K extends keyof Events>(eventName: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): boolean;
+    /**Returns the amount of listeners on that event*/
+    amount<K extends keyof Events>(eventName: K, sub?: SubPath): number;
+    /**Generates a proxy function which can be registered with another handlers */
+    proxy_func(): ESubSubscriber<keyof Events, Target, Events[keyof Events]>;
+}
+/**Extension to event handler with support for sub events*/
+declare class EventHandlerSub<Events extends object, Target> implements EventSubProducer<Events, Target> {
+    #private;
+    target: Target;
+    constructor(target: Target);
+    on<K extends keyof Events>(event_name: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): typeof subscriber;
+    off<K extends keyof Events>(event_name: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): typeof subscriber;
+    proxy_on(subscriber: ESubSubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    proxy_off(subscriber: ESubSubscriber<keyof Events, Target, Events[keyof Events]>): typeof subscriber;
+    get consumer(): EventSubConsumer<Events, Target>;
+    emit<K extends keyof Events>(event_name: K, data: Events[K], sub?: SubPath): void;
+    clear<K extends keyof Events>(event_name: K, sub?: SubPath, any_level?: boolean): void;
+    in_use<K extends keyof Events>(event_name: K, sub?: SubPath): boolean;
+    has<K extends keyof Events>(event_name: K, subscriber: ESubSubscriber<K, Target, Events[K]>, sub?: SubPath): boolean;
+    amount<K extends keyof Events>(event_name: K, sub?: SubPath): number;
+    proxy_func(): ESubSubscriber<keyof Events, Target, Events[keyof Events]>;
+    get producer(): EventSubProducer<Events, Target>;
+}
+
+declare const test: {};
+
+export { E, ESub, type ESubSubscriber, type ESubscriber, type EventConsumer, EventHandler, EventHandlerSub, type EventProducer, type EventSubConsumer, type EventSubProducer, test };

package/dist/index.js

@@ -0,0 +1,315 @@
+// src/simple.ts
+var E = class {
+  /**Any data to pass to the event listeners must be given in the constructor*/
+  constructor(type, target, data) {
+    this.type = type;
+    this.target = target;
+    this.data = data;
+  }
+  /**Type of event */
+  type;
+  /**Reference to */
+  target;
+  /**Data of event */
+  data;
+};
+var EventHandler = class {
+  target;
+  #subscribers = {};
+  #proxies;
+  constructor(target) {
+    this.target = target;
+  }
+  //# Consumer
+  on(event_name, subscriber) {
+    const type_listeners = this.#subscribers[event_name];
+    if (type_listeners) {
+      if (type_listeners.has(subscriber))
+        console.error("Subscriber already in handler");
+      else type_listeners.add(subscriber);
+    } else this.#subscribers[event_name] = /* @__PURE__ */ new Set([subscriber]);
+    return subscriber;
+  }
+  off(event_name, subscriber) {
+    if (this.#subscribers[event_name]?.delete(subscriber) === false)
+      console.error("Subscriber not in handler");
+    return subscriber;
+  }
+  proxy_on(subscriber) {
+    if (!this.#proxies) this.#proxies = /* @__PURE__ */ new Set([subscriber]);
+    else if (!this.#proxies.has(subscriber)) this.#proxies.add(subscriber);
+    else console.error("Proxy subscriber already registered");
+    return subscriber;
+  }
+  proxy_off(subscriber) {
+    if (this.#proxies?.delete(subscriber) === false)
+      console.error("Proxy subscriber not registered");
+    return subscriber;
+  }
+  //# Producer
+  get consumer() {
+    return this;
+  }
+  emit(event_name, data) {
+    const funcs = this.#subscribers[event_name];
+    if (funcs?.size || this.#proxies?.size)
+      this.#emit_e(
+        Object.freeze(
+          new E(event_name, this.target, data)
+        ),
+        funcs
+      );
+  }
+  #emit_e(e, funcs) {
+    this.#proxies?.forEach((proxy) => {
+      proxy(e);
+    });
+    funcs?.forEach((func) => {
+      try {
+        func(e);
+      } catch (e2) {
+        console.error("Failed while dispatching event", e2);
+      }
+    });
+  }
+  clear(event_name) {
+    this.#subscribers[event_name]?.clear();
+  }
+  in_use(event_name) {
+    return Boolean(this.#subscribers[event_name]?.size);
+  }
+  has(event_name, subscriber) {
+    return this.#subscribers[event_name]?.has(subscriber) || false;
+  }
+  amount(event_name) {
+    return this.#subscribers[event_name]?.size || 0;
+  }
+  proxy_func() {
+    return (e) => {
+      const subs = this.#subscribers[e.type];
+      if (subs) this.#emit_e(e, subs);
+    };
+  }
+  get producer() {
+    return this;
+  }
+};
+
+// src/sub.ts
+var ESub = class {
+  /**Any data to pass to the event listeners must be given in the constructor*/
+  constructor(type, target, data, sub) {
+    this.type = type;
+    this.target = target;
+    this.data = data;
+    this.sub = sub;
+  }
+  /**Type of event */
+  type;
+  /**Reference to */
+  target;
+  /**Path to sub event */
+  sub;
+  /**Data of event */
+  data;
+};
+var EventHandlerSub = class {
+  target;
+  #sub_storage = {};
+  #proxies;
+  constructor(target) {
+    this.target = target;
+  }
+  //# Consumer
+  on(event_name, subscriber, sub) {
+    let sub_level = this.#sub_storage[event_name];
+    if (!sub_level)
+      sub_level = this.#sub_storage[event_name] = {
+        subs: {},
+        funcs: /* @__PURE__ */ new Set()
+      };
+    if (sub)
+      for (let i = 0; i < sub.length; i++) {
+        const sub_level_buffer = sub_level.subs[sub[i]];
+        if (sub_level_buffer) sub_level = sub_level_buffer;
+        else
+          sub_level = sub_level.subs[sub[i]] = { subs: {}, funcs: /* @__PURE__ */ new Set() };
+      }
+    const type_listeners = sub_level.funcs;
+    if (type_listeners.has(subscriber))
+      console.error("Subscriber already in handler");
+    else type_listeners.add(subscriber);
+    return subscriber;
+  }
+  off(event_name, subscriber, sub) {
+    let sub_level = this.#sub_storage[event_name];
+    if (sub_level) {
+      if (sub)
+        for (let i = 0; i < sub.length; i++) {
+          const sub_level_buffer = sub_level.subs[sub[i]];
+          if (sub_level_buffer) sub_level = sub_level_buffer;
+          else {
+            console.error("Subscriber not in handler");
+            return subscriber;
+          }
+        }
+      if (sub_level.funcs.delete(subscriber) === false)
+        console.error("Subscriber not in handler");
+    }
+    return subscriber;
+  }
+  proxy_on(subscriber) {
+    if (!this.#proxies) this.#proxies = /* @__PURE__ */ new Set([subscriber]);
+    else if (!this.#proxies.has(subscriber)) this.#proxies.add(subscriber);
+    else console.error("Proxy subscriber already registered");
+    return subscriber;
+  }
+  proxy_off(subscriber) {
+    if (this.#proxies?.delete(subscriber) === false)
+      console.error("Proxy subscriber not registered");
+    return subscriber;
+  }
+  get consumer() {
+    return this;
+  }
+  //#Producer
+  emit(event_name, data, sub) {
+    let funcs;
+    if (sub) {
+      let sub_level = this.#sub_storage[event_name];
+      if (sub_level)
+        for (let i = 0; i < sub.length; i++) {
+          const sub_level_buffer = sub_level.subs[sub[i]];
+          if (sub_level_buffer) sub_level = sub_level_buffer;
+          else if (this.#proxies?.size)
+            return this.#emit_e(
+              Object.freeze(
+                new ESub(
+                  event_name,
+                  this.target,
+                  data,
+                  sub
+                )
+              ),
+              funcs
+            );
+          else return;
+        }
+      funcs = sub_level?.funcs;
+    } else funcs = this.#sub_storage[event_name]?.funcs;
+    if (funcs?.size || this.#proxies?.size)
+      this.#emit_e(
+        Object.freeze(
+          new ESub(event_name, this.target, data, sub)
+        ),
+        funcs
+      );
+  }
+  #emit_e(e, funcs) {
+    this.#proxies?.forEach((proxy) => {
+      proxy(e);
+    });
+    funcs?.forEach((func) => {
+      try {
+        func(e);
+      } catch (e2) {
+        console.error("Failed while dispatching event", e2);
+      }
+    });
+  }
+  clear(event_name, sub, any_level) {
+    let type_buff = this.#sub_storage[event_name];
+    if (type_buff) {
+      if (any_level) {
+        if (sub) {
+          let i = 0;
+          let sub_level = type_buff;
+          for (i; i < sub.length - 1; i++) {
+            const sub_level_buffer = sub_level.subs[sub[i]];
+            if (sub_level_buffer) sub_level = sub_level_buffer;
+            else return;
+          }
+          sub_level.subs[sub[i]] = { subs: {}, funcs: /* @__PURE__ */ new Set() };
+        } else
+          this.#sub_storage[event_name] = {
+            subs: {},
+            funcs: /* @__PURE__ */ new Set()
+          };
+      } else {
+        if (sub)
+          for (let i = 0; i < sub.length; i++) {
+            const sub_level_buffer = type_buff.subs[sub[i]];
+            if (sub_level_buffer) type_buff = sub_level_buffer;
+            else return;
+          }
+        type_buff.funcs.clear();
+      }
+    }
+  }
+  in_use(event_name, sub) {
+    let type_buff = this.#sub_storage[event_name];
+    if (type_buff) {
+      if (sub)
+        for (let i = 0; i < sub.length; i++) {
+          const sub_level_buffer = type_buff.subs[sub[i]];
+          if (sub_level_buffer) type_buff = sub_level_buffer;
+          else return false;
+        }
+      return Boolean(type_buff.funcs.size);
+    } else return false;
+  }
+  has(event_name, subscriber, sub) {
+    let type_buff = this.#sub_storage[event_name];
+    if (type_buff) {
+      if (sub)
+        for (let i = 0; i < sub.length; i++) {
+          const sub_level_buffer = type_buff.subs[sub[i]];
+          if (sub_level_buffer) type_buff = sub_level_buffer;
+          else return false;
+        }
+      return type_buff.funcs.has(subscriber);
+    } else return false;
+  }
+  amount(event_name, sub) {
+    let type_buff = this.#sub_storage[event_name];
+    if (type_buff) {
+      if (sub)
+        for (let i = 0; i < sub.length; i++) {
+          const sub_level_buffer = type_buff.subs[sub[i]];
+          if (sub_level_buffer) type_buff = sub_level_buffer;
+          else return 0;
+        }
+      return type_buff.funcs.size;
+    } else return 0;
+  }
+  proxy_func() {
+    return (e) => {
+      let funcs;
+      if (e.sub) {
+        let sub_level = this.#sub_storage[e.type];
+        if (sub_level)
+          for (let i = 0; i < e.sub.length; i++) {
+            const sub_level_buffer = sub_level.subs[e.sub[i]];
+            if (sub_level_buffer) sub_level = sub_level_buffer;
+            else return;
+          }
+        funcs = sub_level?.funcs;
+      } else funcs = this.#sub_storage[e.type]?.funcs;
+      if (funcs && funcs.size) this.#emit_e(e, funcs);
+    };
+  }
+  get producer() {
+    return this;
+  }
+};
+
+// src/index.ts
+var test = {};
+console.error("YOYOY");
+export {
+  E,
+  ESub,
+  EventHandler,
+  EventHandlerSub,
+  test
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@chocolateish/lib-event",
+  "version": "1.0.0",
+  "description": "A concise description of your library",
+  "author": "chocolateandmilkwin",
+  "license": "MIT",
+  "type": "module",
+  "private": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite --port 9950",
+    "build": "tsup src/index.ts --format esm --dts",
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build",
+    "publish": "npm publish --access public"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.0",
+    "vite": "^7.0.0",
+    "vitest": "^4.0.0",
+    "eslint": "^9.0.0",
+    "typescript-eslint": "^8.0.0",
+    "@vitest/browser-playwright": "^4.0.0"
+  }
+}