event-emission 0.2.1 → 0.3.0

package/dist/index.js

@@ -588,7 +588,17 @@ function createEventTarget(targetOrOpts, opts) {
       "complete",
       "subscribe",
       "toObservable",
-      "events"
+      "events",
+      "emit",
+      "off",
+      "addListener",
+      "removeListener",
+      "prependListener",
+      "prependOnceListener",
+      "listeners",
+      "rawListeners",
+      "listenerCount",
+      "eventNames"
     ];
     for (const name of methodNames) {
       Object.defineProperty(proxy, name, {
@@ -866,7 +876,7 @@ function createEventTargetInternal(opts) {
       }
     }
   };
-  const addEventListener = (type, listener, options) => {
+  const addListenerInternal = (type, listener, options, position) => {
     if (isCompleted || !listener) {
       return () => {};
     }
@@ -893,7 +903,11 @@ function createEventTargetInternal(opts) {
       signal,
       removed: false
     };
-    list.push(record);
+    if (position === "prepend") {
+      list.unshift(record);
+    } else {
+      list.push(record);
+    }
     const unsubscribe2 = () => removeListenerRecord(type, record);
     if (signal) {
       const onAbort = () => removeListenerRecord(type, record);
@@ -904,6 +918,9 @@ function createEventTargetInternal(opts) {
     }
     return unsubscribe2;
   };
+  const addEventListener = (type, listener, options) => {
+    return addListenerInternal(type, listener, options, "append");
+  };
   const addWildcardListener = (pattern, listener, options) => {
     if (isCompleted)
       return () => {};
@@ -1074,7 +1091,18 @@ function createEventTargetInternal(opts) {
     }
     wildcardListeners.clear();
   };
-  const on = (type, options) => {
+  const isListenerArg = (arg) => {
+    if (typeof arg === "function")
+      return true;
+    if (arg && typeof arg === "object" && typeof arg.handleEvent === "function")
+      return true;
+    return false;
+  };
+  const on = (type, optionsOrListener) => {
+    if (isListenerArg(optionsOrListener)) {
+      return addEventListener(type, optionsOrListener);
+    }
+    const options = optionsOrListener;
     return new Observable((observer) => {
       let opts2;
       if (typeof options === "boolean") {
@@ -1430,6 +1458,72 @@ function createEventTargetInternal(opts) {
     };
     return iterator;
   }
+  const emit = (type, detail) => {
+    if (isCompleted)
+      return false;
+    const list = listeners.get(type);
+    const hasListeners = list !== undefined && list.length > 0;
+    let hasWildcard = false;
+    if (wildcardListeners.size > 0) {
+      for (const rec of wildcardListeners) {
+        if (matchesWildcard(type, rec.pattern)) {
+          hasWildcard = true;
+          break;
+        }
+      }
+    }
+    dispatchEvent({ type, detail });
+    return hasListeners || hasWildcard;
+  };
+  const off = (type, listener) => {
+    removeEventListener(type, listener);
+  };
+  const addListener = (type, listener) => {
+    return addEventListener(type, listener);
+  };
+  const removeListener = (type, listener) => {
+    removeEventListener(type, listener);
+  };
+  const prependListener = (type, listener) => {
+    return addListenerInternal(type, listener, undefined, "prepend");
+  };
+  const prependOnceListener = (type, listener) => {
+    return addListenerInternal(type, listener, { once: true }, "prepend");
+  };
+  const getListeners = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return [];
+    return list.filter((r) => !r.removed).map((r) => r.original);
+  };
+  const rawListenersMethod = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return [];
+    return list.filter((r) => !r.removed).map((r) => {
+      if (r.once) {
+        const wrapper = (...args) => r.callback(...args);
+        wrapper.listener = r.original;
+        return wrapper;
+      }
+      return r.original;
+    });
+  };
+  const listenerCount = (type) => {
+    const list = listeners.get(type);
+    if (!list)
+      return 0;
+    return list.filter((r) => !r.removed).length;
+  };
+  const eventNamesMethod = () => {
+    const names = [];
+    for (const [type, list] of listeners) {
+      if (list.some((r) => !r.removed)) {
+        names.push(type);
+      }
+    }
+    return names;
+  };
   const target = {
     addEventListener,
     removeEventListener,
@@ -1447,7 +1541,17 @@ function createEventTargetInternal(opts) {
     },
     subscribe,
     toObservable,
-    events
+    events,
+    emit,
+    off,
+    addListener,
+    removeListener,
+    prependListener,
+    prependOnceListener,
+    listeners: getListeners,
+    rawListeners: rawListenersMethod,
+    listenerCount,
+    eventNames: eventNamesMethod
   };
   target[SymbolObservable] = () => {
     return toObservable();
@@ -1469,8 +1573,8 @@ class EventEmission {
   dispatchEvent(event) {
     return this.#target.dispatchEvent(event);
   }
-  on(type, options) {
-    return this.#target.on(type, options);
+  on(type, optionsOrListener) {
+    return this.#target.on(type, optionsOrListener);
   }
   once(type, listener, options) {
     return this.#target.once(type, listener, options);
@@ -1484,6 +1588,36 @@ class EventEmission {
   pipe(target, mapFn) {
     return this.#target.pipe(target, mapFn);
   }
+  emit(type, detail) {
+    return this.#target.emit(type, detail);
+  }
+  off(type, listener) {
+    this.#target.off(type, listener);
+  }
+  addListener(type, listener) {
+    return this.#target.addListener(type, listener);
+  }
+  removeListener(type, listener) {
+    this.#target.removeListener(type, listener);
+  }
+  prependListener(type, listener) {
+    return this.#target.prependListener(type, listener);
+  }
+  prependOnceListener(type, listener) {
+    return this.#target.prependOnceListener(type, listener);
+  }
+  listeners(type) {
+    return this.#target.listeners(type);
+  }
+  rawListeners(type) {
+    return this.#target.rawListeners(type);
+  }
+  listenerCount(type) {
+    return this.#target.listenerCount(type);
+  }
+  eventNames() {
+    return this.#target.eventNames();
+  }
   addWildcardListener(pattern, listener, options) {
     return this.#target.addWildcardListener(pattern, listener, options);
   }
@@ -1529,4 +1663,4 @@ export {
   BufferOverflowError
 };
 
-//# debugId=60621EDDB80DC90E64756E2164756E21
+//# debugId=320F1C6E7F0CB63D64756E2164756E21