@homer0/events-hub 1.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Leonardo Apiwan (@homer0)
+
+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/README.md

@@ -0,0 +1,129 @@
+# 🚚 Events hub
+
+A simple implementation of a pubsub service for handling events.
+
+It doesn't require any configuration or have customization options: You listen for an event with `on`, emit an event with `emit`, and, you could reduce a variable through an event with `reduce` (or `reduceSync`).
+
+## 🍿 Usage
+
+- ⚙️ [Examples](#%EF%B8%8F-examples)
+- 🤘 [Development](#-development)
+
+### ⚙️ Examples
+
+First, let's create an instance of the hub:
+
+```ts
+import { eventsHub } from '@homer0/events-hub';
+const events = eventsHub();
+```
+
+#### Listen and emit
+
+```ts
+// Add the listener
+events.on('my-event', () => {
+  console.log('The event listener was called!');
+});
+// Emit the event
+events.emit('my-event');
+```
+
+Quite simple, right? You can also send any number of parameters to the events:
+
+```ts
+// Define the listener, to get the parameters' types.
+type LoginListener = (username: string, password: string) => void | Promise<void>;
+// Add the listener
+events.on<LoginListener>('user-login', async (username, password) => {
+  try {
+    const userInfo = await someAuthService.login(username, password);
+    events.emit('user-login-successfull', userInfo);
+  } catch (error) {
+    events.emit('user-login-failed', error);
+  }
+});
+
+//...
+// Emit the event.
+events.emit('user-login', 'rosario', 'p4ssword');
+```
+
+#### Multiple events
+
+All methods that support an event name also support an `Array` with a list of them, which means you can set the same listener for multiple events:
+
+```ts
+// Add the listener
+events.on(['logout-route', 'unauthorized-request'], () => {
+  someAuthService.signout();
+});
+
+//...
+// This would trigger the listener.
+events.emit('logout-route');
+// and this too (if it fails :P).
+someRequest()
+.then(() => ... )
+.catch((error) => {
+  if (error.code === 401) {
+    events.emit('unauthorized-request');
+  }
+});
+```
+
+#### Listening only once
+
+You can use the `once` method to create a subscription that will be removed after being called one time. Following the previous examples, let's say that the `signout` method makes a redirection to a different URL (because of reasons); that means that there's no need to keep the listener around once executed:
+
+```ts
+events.once(['logout-route', 'unauthorized-request'], () => {
+  someAuthService.signout();
+});
+```
+
+After `.signout()` gets called, the listener will be removed.
+
+> Yeah, technically, if `.signout()` does a redirection, it could stop the execution... but you get the point of the example.
+
+#### Reducing a variable
+
+The service has a `reduce` method that is basically the same as `emit`, but the first parameter may be modified by the listeners.
+
+```js
+events.on('filter-users-list', async (list) => {
+  const fromAPI = await getUsersToFilterFromSomeAPI('...', { list });
+  return list.filter((item) => !fromAPI.includes(item));
+});
+
+const usersList = ['Rosario', 'Pilar'];
+const newUsersList = await events.reduce('filter-users-list', usersList);
+// `newUsersList` would now be the users that weren't in the API.
+```
+
+> After the `target`, you can send any number of parameters for the listeners/reducers.
+
+There's also a synchronous version of the `reduce` method: `reduceSync`.
+
+```ts
+events.on('filter-users-list', (list) => {
+  list.slice(1, 3);
+  return list;
+});
+
+const usersList = ['charito', 'Rosario', 'Pilar', 'pili'];
+const newUsersList = events.reduceSync('filter-users-list', usersList);
+console.log(newUsersList);
+// Will log ['Rosario', 'Pilar']
+```
+
+### 🤘 Development
+
+As this project is part of the `packages` monorepo, it requires Yarn, and some of the tooling, like ESLint and Husky, are installed on the root's `package.json`.
+
+#### Yarn tasks
+
+| Task    | Description          |
+| ------- | -------------------- |
+| `test`  | Runs the unit tests. |
+| `build` | Bundles the project. |

package/dist/esm/index.js

@@ -0,0 +1,154 @@
+// src/index.ts
+var EventsHub = class {
+  events = {};
+  onceWrappers = {};
+  getSubscribers(event) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    return this.events[event];
+  }
+  on(event, listener) {
+    const events = Array.isArray(event) ? event : [event];
+    events.forEach((name) => {
+      const subscribers = this.getSubscribers(name);
+      if (!subscribers.includes(listener)) {
+        subscribers.push(listener);
+      }
+    });
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const events = Array.isArray(event) ? event : [event];
+    let wrapper = events.reduce((acc, name) => {
+      if (acc)
+        return acc;
+      const onceWrapper = this.onceWrappers[name];
+      if (Array.isArray(onceWrapper)) {
+        const existing = onceWrapper.find((item) => item.original === listener);
+        if (existing) {
+          return existing.wrapper;
+        }
+        return null;
+      }
+      this.onceWrappers[name] = [];
+      return null;
+    }, null);
+    if (!wrapper) {
+      const newWrapper = (...args) => listener(...args);
+      newWrapper.once = true;
+      wrapper = newWrapper;
+      events.forEach((name) => {
+        this.onceWrappers[name].push({
+          wrapper,
+          original: listener
+        });
+      });
+    }
+    return this.on(event, wrapper);
+  }
+  off(event, listener) {
+    const isArray = Array.isArray(event);
+    const events = isArray ? event : [event];
+    const result = events.map((name) => {
+      const subscribers = this.getSubscribers(name);
+      const onceSubscribers = this.onceWrappers[name];
+      let found = false;
+      let index = subscribers.indexOf(listener);
+      if (index > -1) {
+        found = true;
+        if ("once" in listener && onceSubscribers) {
+          const wrapperIndex = onceSubscribers.findIndex((item) => item.wrapper === listener);
+          onceSubscribers.splice(wrapperIndex, 1);
+        }
+        subscribers.splice(index, 1);
+      } else if (onceSubscribers) {
+        index = onceSubscribers.findIndex((item) => item.original === listener);
+        if (index > -1) {
+          found = true;
+          const originalIndex = subscribers.indexOf(onceSubscribers[index].original);
+          subscribers.splice(originalIndex, 1);
+          onceSubscribers.splice(index, 1);
+        }
+      }
+      return found;
+    });
+    return isArray ? result : result[0];
+  }
+  emit(event, ...args) {
+    const toClean = [];
+    const events = Array.isArray(event) ? event : [event];
+    events.forEach((name) => {
+      this.getSubscribers(name).forEach((subscriber) => {
+        subscriber(...args);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+      });
+    });
+    toClean.forEach((info) => this.off(info.event, info.listener));
+  }
+  async reduce(event, target, ...args) {
+    const events = Array.isArray(event) ? event : [event];
+    const toClean = [];
+    const result = await events.reduce((eventAcc, name) => eventAcc.then((eventCurrent) => {
+      const subscribers = this.getSubscribers(name);
+      return subscribers.reduce((subAcc, subscriber) => subAcc.then((subCurrent) => {
+        let useCurrent;
+        if (Array.isArray(subCurrent)) {
+          useCurrent = subCurrent.slice();
+        } else if (typeof subCurrent === "object") {
+          useCurrent = { ...subCurrent };
+        } else {
+          useCurrent = subCurrent;
+        }
+        const nextStep = subscriber(...[useCurrent, ...args]);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+        return nextStep;
+      }), Promise.resolve(eventCurrent));
+    }), Promise.resolve(target));
+    toClean.forEach((info) => this.off(info.event, info.listener));
+    return result;
+  }
+  reduceSync(event, target, ...args) {
+    const events = Array.isArray(event) ? event : [event];
+    const toClean = [];
+    const result = events.reduce((eventAcc, name) => {
+      const subscribers = this.getSubscribers(name);
+      return subscribers.reduce((subAcc, subscriber) => {
+        let useCurrent;
+        if (Array.isArray(subAcc)) {
+          useCurrent = subAcc.slice();
+        } else if (typeof subAcc === "object") {
+          useCurrent = { ...subAcc };
+        } else {
+          useCurrent = subAcc;
+        }
+        const nextStep = subscriber(...[useCurrent, ...args]);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+        return nextStep;
+      }, eventAcc);
+    }, target);
+    toClean.forEach((info) => this.off(info.event, info.listener));
+    return result;
+  }
+};
+var eventsHub = () => new EventsHub();
+export {
+  EventsHub,
+  eventsHub
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any -- It's a generic function.\ntype GenericFn = (...args: any[]) => any;\ntype GenericParams = Parameters<GenericFn>;\ntype OnceWrapperFn = GenericFn & {\n  once: boolean;\n};\n/**\n * When the service receives a \"once subscription\", it needs to track the listener so it\n * gets removed after being called once, and to avoid modifying the original function, it\n * creates a wrapper function that has the \"once\" property set to true. The wrapper and\n * the original function are stored in case `off` is called before the wrapper gets\n * triggered; it will receive the original function, not the wrapper, so the class needs a\n * way to map them together.\n */\ntype OnceWrapper = {\n  /**\n   * A simple wrapper for the original listener, with the difference that it has a `once`\n   * property set to `true`.\n   */\n  wrapper: OnceWrapperFn;\n  /**\n   * The original listener that will be called once.\n   */\n  original: GenericFn;\n};\n/**\n * A minimal implementation of an events handler service.\n */\nexport class EventsHub {\n  /**\n   * A dictionary of the events and their listeners.\n   */\n  protected events: Record<string, GenericFn[]> = {};\n  /**\n   * A dictionary of wrappers that were created for \"one time subscriptions\". This is\n   * used by the {@link EventsHub.off}: if it doesn't find the subscriber as it is, it\n   * will look for a wrapper and remove it.\n   */\n  protected onceWrappers: Record<string, OnceWrapper[]> = {};\n  /**\n   * Gets all the listeners for a specific event.\n   * The list is returned by reference, so it can be modified once obtained.\n   *\n   * @param event  The name of the event.\n   */\n  protected getSubscribers(event: string): (GenericFn | OnceWrapperFn)[] {\n    if (!this.events[event]) {\n      this.events[event] = [];\n    }\n\n    return this.events[event]!;\n  }\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): () => boolean;\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): () => boolean[];\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[];\n  /**\n   * Adds a new event listener.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listene(s).\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   type Listener = (arg0: string) => void;\n   *   const unsubscribe = events.on<Listener>('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *\n   */\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[] {\n    const events = Array.isArray(event) ? event : [event];\n    events.forEach((name) => {\n      const subscribers = this.getSubscribers(name);\n      if (!subscribers.includes(listener)) {\n        subscribers.push(listener);\n      }\n    });\n\n    return () => this.off<ListenerFn>(event, listener);\n  }\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): () => boolean;\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): () => boolean[];\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[];\n  /**\n   * Adds an event listener that will only be executed once.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listener(s).\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   type Listener = (arg0: string) => void;\n   *   const unsubscribe = events.once<Listener>('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *\n   */\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[] {\n    const events = Array.isArray(event) ? event : [event];\n    // Try to find an existing wrapper.\n    let wrapper = events.reduce<OnceWrapperFn | null>((acc, name) => {\n      // A previous iteration found a wrapper, so `continue`.\n      if (acc) return acc;\n\n      // A list of wrappers exists for the event, so, let's try an find one for this function.\n      const onceWrapper = this.onceWrappers[name];\n      if (Array.isArray(onceWrapper)) {\n        const existing = onceWrapper.find((item) => item.original === listener);\n        if (existing) {\n          return existing.wrapper;\n        }\n\n        return null;\n      }\n\n      // The list didn't even exists, let's at least create it.\n      this.onceWrappers[name] = [];\n      return null;\n    }, null);\n\n    if (!wrapper) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- It's a generic function.\n      const newWrapper = (...args: any[]) => listener(...args);\n      newWrapper.once = true;\n      wrapper = newWrapper;\n      events.forEach((name) => {\n        this.onceWrappers[name]!.push({\n          wrapper: wrapper!,\n          original: listener,\n        });\n      });\n    }\n\n    return this.on(event, wrapper);\n  }\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): boolean[];\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): boolean;\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): boolean | boolean[];\n  /**\n   * Removes an event listener.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns If `event` was a `string`, it will return whether or not the listener was\n   *          found and removed; but if `event`\n   *          was an `Array`, it will return a list of boolean values.\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   const listener = (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   };\n   *   events.on('event', listener); // subscribe.\n   *   events.off('event', listener); // manually unsubscribe.\n   *\n   */\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): boolean | boolean[] {\n    const isArray = Array.isArray(event);\n    const events = isArray ? event : [event];\n    const result = events.map((name) => {\n      const subscribers = this.getSubscribers(name);\n      const onceSubscribers = this.onceWrappers[name];\n      let found = false;\n      let index = subscribers.indexOf(listener);\n      if (index > -1) {\n        found = true;\n        /**\n         * If the listener had the `once` flag, then it's a wrapper, so it needs to remove\n         * it from the wrappers list too.\n         */\n        if ('once' in listener && onceSubscribers) {\n          const wrapperIndex = onceSubscribers.findIndex(\n            (item) => item.wrapper === listener,\n          );\n          onceSubscribers.splice(wrapperIndex, 1);\n        }\n        subscribers.splice(index, 1);\n      } else if (onceSubscribers) {\n        /**\n         * If it couldn't found the subscriber, maybe it's because it's the original\n         * listener of a wrapper.\n         */\n        index = onceSubscribers.findIndex((item) => item.original === listener);\n        if (index > -1) {\n          found = true;\n          const originalIndex = subscribers.indexOf(onceSubscribers[index]!.original);\n          subscribers.splice(originalIndex, 1);\n          onceSubscribers.splice(index, 1);\n        }\n      }\n\n      return found;\n    });\n\n    return isArray ? result : result[0]!;\n  }\n  /**\n   * Emits an event and call all its listeners.\n   *\n   * @param event  An event name or a list of them.\n   * @param args   A list of parameters to send to the listeners.\n   * @template Args  The type of the parameters to send to the listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *   events.emit('event', 'Hello'); // prints \"Event received: Hello\"\n   *\n   */\n  emit<Args extends GenericParams>(event: string | string[], ...args: Args): void {\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const events = Array.isArray(event) ? event : [event];\n    events.forEach((name) => {\n      this.getSubscribers(name).forEach((subscriber) => {\n        subscriber(...args);\n        if ('once' in subscriber) {\n          toClean.push({\n            event: name,\n            listener: subscriber,\n          });\n        }\n      });\n    });\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n  }\n  /**\n   * Asynchronously reduces a target using an event. It's like emit, but the events\n   * listener return a modified (or not) version of the `target`.\n   *\n   * @param event   An event name or a list of them.\n   * @param target  The variable to reduce with the reducers/listeners.\n   * @param args    A list of parameters to send to the reducers/listeners.\n   * @returns A version of the `target` processed by the listeners.\n   * @template Target  The type of the target.\n   * @template Args    The type of the parameters to send to the reducers/listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', async (target, arg0) => {\n   *     const data = await fetch(`https://api.example.com/${arg0}`);\n   *     target.push(data);\n   *     return target;\n   *   });\n   *   const result = await events.reduce('event', [], 'Hello');\n   *   // result would be a list of data fetched from the API.\n   *\n   */\n  async reduce<Target, Args extends GenericParams>(\n    event: string | string[],\n    target: Target,\n    ...args: Args\n  ): Promise<Target> {\n    const events = Array.isArray(event) ? event : [event];\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const result = await events.reduce<Promise<Target>>(\n      (eventAcc, name) =>\n        eventAcc.then((eventCurrent) => {\n          const subscribers = this.getSubscribers(name);\n          return subscribers.reduce(\n            (subAcc, subscriber) =>\n              subAcc.then((subCurrent) => {\n                let useCurrent;\n                if (Array.isArray(subCurrent)) {\n                  useCurrent = subCurrent.slice();\n                } else if (typeof subCurrent === 'object') {\n                  useCurrent = { ...subCurrent };\n                } else {\n                  useCurrent = subCurrent;\n                }\n\n                const nextStep = subscriber(...[useCurrent, ...args]);\n                if ('once' in subscriber) {\n                  toClean.push({\n                    event: name,\n                    listener: subscriber,\n                  });\n                }\n\n                return nextStep;\n              }),\n            Promise.resolve(eventCurrent),\n          );\n        }),\n      Promise.resolve(target),\n    );\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n\n    return result;\n  }\n  /**\n   * Synchronously reduces a target using an event. It's like emit, but the events\n   * listener return a modified (or not) version of the `target`.\n   *\n   * @param event   An event name or a list of them.\n   * @param target  The variable to reduce with the reducers/listeners.\n   * @param args    A list of parameters to send to the reducers/listeners.\n   * @returns A version of the `target` processed by the listeners.\n   * @template Target  The type of the target.\n   * @template Args    The type of the parameters to send to the reducers/listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', (target, arg0) => {\n   *     target.push(arg0);\n   *     return target;\n   *   });\n   *   events.reduce('event', [], 'Hello'); // returns ['Hello']\n   *\n   */\n  reduceSync<Target, ReducerArgs extends GenericParams>(\n    event: string | string[],\n    target: Target,\n    ...args: ReducerArgs\n  ): Target {\n    const events = Array.isArray(event) ? event : [event];\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const result = events.reduce((eventAcc, name) => {\n      const subscribers = this.getSubscribers(name);\n      return subscribers.reduce((subAcc, subscriber) => {\n        let useCurrent;\n        if (Array.isArray(subAcc)) {\n          useCurrent = subAcc.slice();\n        } else if (typeof subAcc === 'object') {\n          useCurrent = { ...subAcc };\n        } else {\n          useCurrent = subAcc;\n        }\n\n        const nextStep = subscriber(...[useCurrent, ...args]);\n        if ('once' in subscriber) {\n          toClean.push({\n            event: name,\n            listener: subscriber,\n          });\n        }\n\n        return nextStep;\n      }, eventAcc);\n    }, target);\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n    return result;\n  }\n}\n/**\n * Shorthand for `new EventsHub()`.\n *\n * @returns A new instance of {@link EventsHub}.\n */\nexport const eventsHub = () => new EventsHub();\n"],"mappings":";AA4BO,IAAM,YAAN,MAAgB;AAAA,EAIrB,AAAU,SAAsC,CAAC;AAAA,EAMjD,AAAU,eAA8C,CAAC;AAAA,EAOzD,AAAU,eAAe,OAA8C;AACrE,QAAI,CAAC,KAAK,OAAO,QAAQ;AACvB,WAAK,OAAO,SAAS,CAAC;AAAA,IACxB;AAEA,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA,EA6BA,GACE,OACA,UAC2B;AAC3B,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AACpD,WAAO,QAAQ,CAAC,SAAS;AACvB,YAAM,cAAc,KAAK,eAAe,IAAI;AAC5C,UAAI,CAAC,YAAY,SAAS,QAAQ,GAAG;AACnC,oBAAY,KAAK,QAAQ;AAAA,MAC3B;AAAA,IACF,CAAC;AAED,WAAO,MAAM,KAAK,IAAgB,OAAO,QAAQ;AAAA,EACnD;AAAA,EA6BA,KACE,OACA,UAC2B;AAC3B,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AAEpD,QAAI,UAAU,OAAO,OAA6B,CAAC,KAAK,SAAS;AAE/D,UAAI;AAAK,eAAO;AAGhB,YAAM,cAAc,KAAK,aAAa;AACtC,UAAI,MAAM,QAAQ,WAAW,GAAG;AAC9B,cAAM,WAAW,YAAY,KAAK,CAAC,SAAS,KAAK,aAAa,QAAQ;AACtE,YAAI,UAAU;AACZ,iBAAO,SAAS;AAAA,QAClB;AAEA,eAAO;AAAA,MACT;AAGA,WAAK,aAAa,QAAQ,CAAC;AAC3B,aAAO;AAAA,IACT,GAAG,IAAI;AAEP,QAAI,CAAC,SAAS;AAEZ,YAAM,aAAa,IAAI,SAAgB,SAAS,GAAG,IAAI;AACvD,iBAAW,OAAO;AAClB,gBAAU;AACV,aAAO,QAAQ,CAAC,SAAS;AACvB,aAAK,aAAa,MAAO,KAAK;AAAA,UAC5B;AAAA,UACA,UAAU;AAAA,QACZ,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAEA,WAAO,KAAK,GAAG,OAAO,OAAO;AAAA,EAC/B;AAAA,EAgCA,IACE,OACA,UACqB;AACrB,UAAM,UAAU,MAAM,QAAQ,KAAK;AACnC,UAAM,SAAS,UAAU,QAAQ,CAAC,KAAK;AACvC,UAAM,SAAS,OAAO,IAAI,CAAC,SAAS;AAClC,YAAM,cAAc,KAAK,eAAe,IAAI;AAC5C,YAAM,kBAAkB,KAAK,aAAa;AAC1C,UAAI,QAAQ;AACZ,UAAI,QAAQ,YAAY,QAAQ,QAAQ;AACxC,UAAI,QAAQ,IAAI;AACd,gBAAQ;AAKR,YAAI,UAAU,YAAY,iBAAiB;AACzC,gBAAM,eAAe,gBAAgB,UACnC,CAAC,SAAS,KAAK,YAAY,QAC7B;AACA,0BAAgB,OAAO,cAAc,CAAC;AAAA,QACxC;AACA,oBAAY,OAAO,OAAO,CAAC;AAAA,MAC7B,WAAW,iBAAiB;AAK1B,gBAAQ,gBAAgB,UAAU,CAAC,SAAS,KAAK,aAAa,QAAQ;AACtE,YAAI,QAAQ,IAAI;AACd,kBAAQ;AACR,gBAAM,gBAAgB,YAAY,QAAQ,gBAAgB,OAAQ,QAAQ;AAC1E,sBAAY,OAAO,eAAe,CAAC;AACnC,0BAAgB,OAAO,OAAO,CAAC;AAAA,QACjC;AAAA,MACF;AAEA,aAAO;AAAA,IACT,CAAC;AAED,WAAO,UAAU,SAAS,OAAO;AAAA,EACnC;AAAA,EAgBA,KAAiC,UAA6B,MAAkB;AAC9E,UAAM,UAAoD,CAAC;AAC3D,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AACpD,WAAO,QAAQ,CAAC,SAAS;AACvB,WAAK,eAAe,IAAI,EAAE,QAAQ,CAAC,eAAe;AAChD,mBAAW,GAAG,IAAI;AAClB,YAAI,UAAU,YAAY;AACxB,kBAAQ,KAAK;AAAA,YACX,OAAO;AAAA,YACP,UAAU;AAAA,UACZ,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,YAAQ,QAAQ,CAAC,SAAS,KAAK,IAAI,KAAK,OAAO,KAAK,QAAQ,CAAC;AAAA,EAC/D;AAAA,EAuBA,MAAM,OACJ,OACA,WACG,MACc;AACjB,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AACpD,UAAM,UAAoD,CAAC;AAC3D,UAAM,SAAS,MAAM,OAAO,OAC1B,CAAC,UAAU,SACT,SAAS,KAAK,CAAC,iBAAiB;AAC9B,YAAM,cAAc,KAAK,eAAe,IAAI;AAC5C,aAAO,YAAY,OACjB,CAAC,QAAQ,eACP,OAAO,KAAK,CAAC,eAAe;AAC1B,YAAI;AACJ,YAAI,MAAM,QAAQ,UAAU,GAAG;AAC7B,uBAAa,WAAW,MAAM;AAAA,QAChC,WAAW,OAAO,eAAe,UAAU;AACzC,uBAAa,EAAE,GAAG,WAAW;AAAA,QAC/B,OAAO;AACL,uBAAa;AAAA,QACf;AAEA,cAAM,WAAW,WAAW,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC;AACpD,YAAI,UAAU,YAAY;AACxB,kBAAQ,KAAK;AAAA,YACX,OAAO;AAAA,YACP,UAAU;AAAA,UACZ,CAAC;AAAA,QACH;AAEA,eAAO;AAAA,MACT,CAAC,GACH,QAAQ,QAAQ,YAAY,CAC9B;AAAA,IACF,CAAC,GACH,QAAQ,QAAQ,MAAM,CACxB;AAEA,YAAQ,QAAQ,CAAC,SAAS,KAAK,IAAI,KAAK,OAAO,KAAK,QAAQ,CAAC;AAE7D,WAAO;AAAA,EACT;AAAA,EAqBA,WACE,OACA,WACG,MACK;AACR,UAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AACpD,UAAM,UAAoD,CAAC;AAC3D,UAAM,SAAS,OAAO,OAAO,CAAC,UAAU,SAAS;AAC/C,YAAM,cAAc,KAAK,eAAe,IAAI;AAC5C,aAAO,YAAY,OAAO,CAAC,QAAQ,eAAe;AAChD,YAAI;AACJ,YAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,uBAAa,OAAO,MAAM;AAAA,QAC5B,WAAW,OAAO,WAAW,UAAU;AACrC,uBAAa,EAAE,GAAG,OAAO;AAAA,QAC3B,OAAO;AACL,uBAAa;AAAA,QACf;AAEA,cAAM,WAAW,WAAW,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC;AACpD,YAAI,UAAU,YAAY;AACxB,kBAAQ,KAAK;AAAA,YACX,OAAO;AAAA,YACP,UAAU;AAAA,UACZ,CAAC;AAAA,QACH;AAEA,eAAO;AAAA,MACT,GAAG,QAAQ;AAAA,IACb,GAAG,MAAM;AAET,YAAQ,QAAQ,CAAC,SAAS,KAAK,IAAI,KAAK,OAAO,KAAK,QAAQ,CAAC;AAC7D,WAAO;AAAA,EACT;AACF;AAMO,IAAM,YAAY,MAAM,IAAI,UAAU;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+declare type GenericFn = (...args: any[]) => any;
+declare type GenericParams = Parameters<GenericFn>;
+declare type OnceWrapperFn = GenericFn & {
+    once: boolean;
+};
+/**
+ * When the service receives a "once subscription", it needs to track the listener so it
+ * gets removed after being called once, and to avoid modifying the original function, it
+ * creates a wrapper function that has the "once" property set to true. The wrapper and
+ * the original function are stored in case `off` is called before the wrapper gets
+ * triggered; it will receive the original function, not the wrapper, so the class needs a
+ * way to map them together.
+ */
+declare type OnceWrapper = {
+    /**
+     * A simple wrapper for the original listener, with the difference that it has a `once`
+     * property set to `true`.
+     */
+    wrapper: OnceWrapperFn;
+    /**
+     * The original listener that will be called once.
+     */
+    original: GenericFn;
+};
+/**
+ * A minimal implementation of an events handler service.
+ */
+declare class EventsHub {
+    /**
+     * A dictionary of the events and their listeners.
+     */
+    protected events: Record<string, GenericFn[]>;
+    /**
+     * A dictionary of wrappers that were created for "one time subscriptions". This is
+     * used by the {@link EventsHub.off}: if it doesn't find the subscriber as it is, it
+     * will look for a wrapper and remove it.
+     */
+    protected onceWrappers: Record<string, OnceWrapper[]>;
+    /**
+     * Gets all the listeners for a specific event.
+     * The list is returned by reference, so it can be modified once obtained.
+     *
+     * @param event  The name of the event.
+     */
+    protected getSubscribers(event: string): (GenericFn | OnceWrapperFn)[];
+    on<ListenerFn extends GenericFn = GenericFn>(event: string, listener: ListenerFn): () => boolean;
+    on<ListenerFn extends GenericFn = GenericFn>(event: string[], listener: ListenerFn): () => boolean[];
+    on<ListenerFn extends GenericFn = GenericFn>(event: string | string[], listener: ListenerFn): () => boolean | boolean[];
+    once<ListenerFn extends GenericFn = GenericFn>(event: string, listener: ListenerFn): () => boolean;
+    once<ListenerFn extends GenericFn = GenericFn>(event: string[], listener: ListenerFn): () => boolean[];
+    once<ListenerFn extends GenericFn = GenericFn>(event: string | string[], listener: ListenerFn): () => boolean | boolean[];
+    off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(event: string[], listener: ListenerFn): boolean[];
+    off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(event: string, listener: ListenerFn): boolean;
+    off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(event: string | string[], listener: ListenerFn): boolean | boolean[];
+    /**
+     * Emits an event and call all its listeners.
+     *
+     * @param event  An event name or a list of them.
+     * @param args   A list of parameters to send to the listeners.
+     * @template Args  The type of the parameters to send to the listeners.
+     * @example
+     *
+     *   const events = new EventsHub();
+     *   events.on('event', (arg0) => {
+     *     console.log(`Event received: ${arg0}`);
+     *   });
+     *   events.emit('event', 'Hello'); // prints "Event received: Hello"
+     *
+     */
+    emit<Args extends GenericParams>(event: string | string[], ...args: Args): void;
+    /**
+     * Asynchronously reduces a target using an event. It's like emit, but the events
+     * listener return a modified (or not) version of the `target`.
+     *
+     * @param event   An event name or a list of them.
+     * @param target  The variable to reduce with the reducers/listeners.
+     * @param args    A list of parameters to send to the reducers/listeners.
+     * @returns A version of the `target` processed by the listeners.
+     * @template Target  The type of the target.
+     * @template Args    The type of the parameters to send to the reducers/listeners.
+     * @example
+     *
+     *   const events = new EventsHub();
+     *   events.on('event', async (target, arg0) => {
+     *     const data = await fetch(`https://api.example.com/${arg0}`);
+     *     target.push(data);
+     *     return target;
+     *   });
+     *   const result = await events.reduce('event', [], 'Hello');
+     *   // result would be a list of data fetched from the API.
+     *
+     */
+    reduce<Target, Args extends GenericParams>(event: string | string[], target: Target, ...args: Args): Promise<Target>;
+    /**
+     * Synchronously reduces a target using an event. It's like emit, but the events
+     * listener return a modified (or not) version of the `target`.
+     *
+     * @param event   An event name or a list of them.
+     * @param target  The variable to reduce with the reducers/listeners.
+     * @param args    A list of parameters to send to the reducers/listeners.
+     * @returns A version of the `target` processed by the listeners.
+     * @template Target  The type of the target.
+     * @template Args    The type of the parameters to send to the reducers/listeners.
+     * @example
+     *
+     *   const events = new EventsHub();
+     *   events.on('event', (target, arg0) => {
+     *     target.push(arg0);
+     *     return target;
+     *   });
+     *   events.reduce('event', [], 'Hello'); // returns ['Hello']
+     *
+     */
+    reduceSync<Target, ReducerArgs extends GenericParams>(event: string | string[], target: Target, ...args: ReducerArgs): Target;
+}
+/**
+ * Shorthand for `new EventsHub()`.
+ *
+ * @returns A new instance of {@link EventsHub}.
+ */
+declare const eventsHub: () => EventsHub;
+
+export { EventsHub, eventsHub };

package/dist/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  EventsHub: () => EventsHub,
+  eventsHub: () => eventsHub
+});
+module.exports = __toCommonJS(src_exports);
+var EventsHub = class {
+  events = {};
+  onceWrappers = {};
+  getSubscribers(event) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    return this.events[event];
+  }
+  on(event, listener) {
+    const events = Array.isArray(event) ? event : [event];
+    events.forEach((name) => {
+      const subscribers = this.getSubscribers(name);
+      if (!subscribers.includes(listener)) {
+        subscribers.push(listener);
+      }
+    });
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const events = Array.isArray(event) ? event : [event];
+    let wrapper = events.reduce((acc, name) => {
+      if (acc)
+        return acc;
+      const onceWrapper = this.onceWrappers[name];
+      if (Array.isArray(onceWrapper)) {
+        const existing = onceWrapper.find((item) => item.original === listener);
+        if (existing) {
+          return existing.wrapper;
+        }
+        return null;
+      }
+      this.onceWrappers[name] = [];
+      return null;
+    }, null);
+    if (!wrapper) {
+      const newWrapper = (...args) => listener(...args);
+      newWrapper.once = true;
+      wrapper = newWrapper;
+      events.forEach((name) => {
+        this.onceWrappers[name].push({
+          wrapper,
+          original: listener
+        });
+      });
+    }
+    return this.on(event, wrapper);
+  }
+  off(event, listener) {
+    const isArray = Array.isArray(event);
+    const events = isArray ? event : [event];
+    const result = events.map((name) => {
+      const subscribers = this.getSubscribers(name);
+      const onceSubscribers = this.onceWrappers[name];
+      let found = false;
+      let index = subscribers.indexOf(listener);
+      if (index > -1) {
+        found = true;
+        if ("once" in listener && onceSubscribers) {
+          const wrapperIndex = onceSubscribers.findIndex((item) => item.wrapper === listener);
+          onceSubscribers.splice(wrapperIndex, 1);
+        }
+        subscribers.splice(index, 1);
+      } else if (onceSubscribers) {
+        index = onceSubscribers.findIndex((item) => item.original === listener);
+        if (index > -1) {
+          found = true;
+          const originalIndex = subscribers.indexOf(onceSubscribers[index].original);
+          subscribers.splice(originalIndex, 1);
+          onceSubscribers.splice(index, 1);
+        }
+      }
+      return found;
+    });
+    return isArray ? result : result[0];
+  }
+  emit(event, ...args) {
+    const toClean = [];
+    const events = Array.isArray(event) ? event : [event];
+    events.forEach((name) => {
+      this.getSubscribers(name).forEach((subscriber) => {
+        subscriber(...args);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+      });
+    });
+    toClean.forEach((info) => this.off(info.event, info.listener));
+  }
+  async reduce(event, target, ...args) {
+    const events = Array.isArray(event) ? event : [event];
+    const toClean = [];
+    const result = await events.reduce((eventAcc, name) => eventAcc.then((eventCurrent) => {
+      const subscribers = this.getSubscribers(name);
+      return subscribers.reduce((subAcc, subscriber) => subAcc.then((subCurrent) => {
+        let useCurrent;
+        if (Array.isArray(subCurrent)) {
+          useCurrent = subCurrent.slice();
+        } else if (typeof subCurrent === "object") {
+          useCurrent = { ...subCurrent };
+        } else {
+          useCurrent = subCurrent;
+        }
+        const nextStep = subscriber(...[useCurrent, ...args]);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+        return nextStep;
+      }), Promise.resolve(eventCurrent));
+    }), Promise.resolve(target));
+    toClean.forEach((info) => this.off(info.event, info.listener));
+    return result;
+  }
+  reduceSync(event, target, ...args) {
+    const events = Array.isArray(event) ? event : [event];
+    const toClean = [];
+    const result = events.reduce((eventAcc, name) => {
+      const subscribers = this.getSubscribers(name);
+      return subscribers.reduce((subAcc, subscriber) => {
+        let useCurrent;
+        if (Array.isArray(subAcc)) {
+          useCurrent = subAcc.slice();
+        } else if (typeof subAcc === "object") {
+          useCurrent = { ...subAcc };
+        } else {
+          useCurrent = subAcc;
+        }
+        const nextStep = subscriber(...[useCurrent, ...args]);
+        if ("once" in subscriber) {
+          toClean.push({
+            event: name,
+            listener: subscriber
+          });
+        }
+        return nextStep;
+      }, eventAcc);
+    }, target);
+    toClean.forEach((info) => this.off(info.event, info.listener));
+    return result;
+  }
+};
+var eventsHub = () => new EventsHub();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventsHub,
+  eventsHub
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any -- It's a generic function.\ntype GenericFn = (...args: any[]) => any;\ntype GenericParams = Parameters<GenericFn>;\ntype OnceWrapperFn = GenericFn & {\n  once: boolean;\n};\n/**\n * When the service receives a \"once subscription\", it needs to track the listener so it\n * gets removed after being called once, and to avoid modifying the original function, it\n * creates a wrapper function that has the \"once\" property set to true. The wrapper and\n * the original function are stored in case `off` is called before the wrapper gets\n * triggered; it will receive the original function, not the wrapper, so the class needs a\n * way to map them together.\n */\ntype OnceWrapper = {\n  /**\n   * A simple wrapper for the original listener, with the difference that it has a `once`\n   * property set to `true`.\n   */\n  wrapper: OnceWrapperFn;\n  /**\n   * The original listener that will be called once.\n   */\n  original: GenericFn;\n};\n/**\n * A minimal implementation of an events handler service.\n */\nexport class EventsHub {\n  /**\n   * A dictionary of the events and their listeners.\n   */\n  protected events: Record<string, GenericFn[]> = {};\n  /**\n   * A dictionary of wrappers that were created for \"one time subscriptions\". This is\n   * used by the {@link EventsHub.off}: if it doesn't find the subscriber as it is, it\n   * will look for a wrapper and remove it.\n   */\n  protected onceWrappers: Record<string, OnceWrapper[]> = {};\n  /**\n   * Gets all the listeners for a specific event.\n   * The list is returned by reference, so it can be modified once obtained.\n   *\n   * @param event  The name of the event.\n   */\n  protected getSubscribers(event: string): (GenericFn | OnceWrapperFn)[] {\n    if (!this.events[event]) {\n      this.events[event] = [];\n    }\n\n    return this.events[event]!;\n  }\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): () => boolean;\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): () => boolean[];\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[];\n  /**\n   * Adds a new event listener.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listene(s).\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   type Listener = (arg0: string) => void;\n   *   const unsubscribe = events.on<Listener>('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *\n   */\n  on<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[] {\n    const events = Array.isArray(event) ? event : [event];\n    events.forEach((name) => {\n      const subscribers = this.getSubscribers(name);\n      if (!subscribers.includes(listener)) {\n        subscribers.push(listener);\n      }\n    });\n\n    return () => this.off<ListenerFn>(event, listener);\n  }\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): () => boolean;\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): () => boolean[];\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[];\n  /**\n   * Adds an event listener that will only be executed once.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listener(s).\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   type Listener = (arg0: string) => void;\n   *   const unsubscribe = events.once<Listener>('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *\n   */\n  once<ListenerFn extends GenericFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): () => boolean | boolean[] {\n    const events = Array.isArray(event) ? event : [event];\n    // Try to find an existing wrapper.\n    let wrapper = events.reduce<OnceWrapperFn | null>((acc, name) => {\n      // A previous iteration found a wrapper, so `continue`.\n      if (acc) return acc;\n\n      // A list of wrappers exists for the event, so, let's try an find one for this function.\n      const onceWrapper = this.onceWrappers[name];\n      if (Array.isArray(onceWrapper)) {\n        const existing = onceWrapper.find((item) => item.original === listener);\n        if (existing) {\n          return existing.wrapper;\n        }\n\n        return null;\n      }\n\n      // The list didn't even exists, let's at least create it.\n      this.onceWrappers[name] = [];\n      return null;\n    }, null);\n\n    if (!wrapper) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- It's a generic function.\n      const newWrapper = (...args: any[]) => listener(...args);\n      newWrapper.once = true;\n      wrapper = newWrapper;\n      events.forEach((name) => {\n        this.onceWrappers[name]!.push({\n          wrapper: wrapper!,\n          original: listener,\n        });\n      });\n    }\n\n    return this.on(event, wrapper);\n  }\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string[],\n    listener: ListenerFn,\n  ): boolean[];\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string,\n    listener: ListenerFn,\n  ): boolean;\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): boolean | boolean[];\n  /**\n   * Removes an event listener.\n   *\n   * @param event     An event name or a list of them.\n   * @param listener  The listener function.\n   * @returns If `event` was a `string`, it will return whether or not the listener was\n   *          found and removed; but if `event`\n   *          was an `Array`, it will return a list of boolean values.\n   * @template ListenerFn  The type of the listener function.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   const listener = (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   };\n   *   events.on('event', listener); // subscribe.\n   *   events.off('event', listener); // manually unsubscribe.\n   *\n   */\n  off<ListenerFn extends GenericFn | OnceWrapperFn = GenericFn>(\n    event: string | string[],\n    listener: ListenerFn,\n  ): boolean | boolean[] {\n    const isArray = Array.isArray(event);\n    const events = isArray ? event : [event];\n    const result = events.map((name) => {\n      const subscribers = this.getSubscribers(name);\n      const onceSubscribers = this.onceWrappers[name];\n      let found = false;\n      let index = subscribers.indexOf(listener);\n      if (index > -1) {\n        found = true;\n        /**\n         * If the listener had the `once` flag, then it's a wrapper, so it needs to remove\n         * it from the wrappers list too.\n         */\n        if ('once' in listener && onceSubscribers) {\n          const wrapperIndex = onceSubscribers.findIndex(\n            (item) => item.wrapper === listener,\n          );\n          onceSubscribers.splice(wrapperIndex, 1);\n        }\n        subscribers.splice(index, 1);\n      } else if (onceSubscribers) {\n        /**\n         * If it couldn't found the subscriber, maybe it's because it's the original\n         * listener of a wrapper.\n         */\n        index = onceSubscribers.findIndex((item) => item.original === listener);\n        if (index > -1) {\n          found = true;\n          const originalIndex = subscribers.indexOf(onceSubscribers[index]!.original);\n          subscribers.splice(originalIndex, 1);\n          onceSubscribers.splice(index, 1);\n        }\n      }\n\n      return found;\n    });\n\n    return isArray ? result : result[0]!;\n  }\n  /**\n   * Emits an event and call all its listeners.\n   *\n   * @param event  An event name or a list of them.\n   * @param args   A list of parameters to send to the listeners.\n   * @template Args  The type of the parameters to send to the listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', (arg0) => {\n   *     console.log(`Event received: ${arg0}`);\n   *   });\n   *   events.emit('event', 'Hello'); // prints \"Event received: Hello\"\n   *\n   */\n  emit<Args extends GenericParams>(event: string | string[], ...args: Args): void {\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const events = Array.isArray(event) ? event : [event];\n    events.forEach((name) => {\n      this.getSubscribers(name).forEach((subscriber) => {\n        subscriber(...args);\n        if ('once' in subscriber) {\n          toClean.push({\n            event: name,\n            listener: subscriber,\n          });\n        }\n      });\n    });\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n  }\n  /**\n   * Asynchronously reduces a target using an event. It's like emit, but the events\n   * listener return a modified (or not) version of the `target`.\n   *\n   * @param event   An event name or a list of them.\n   * @param target  The variable to reduce with the reducers/listeners.\n   * @param args    A list of parameters to send to the reducers/listeners.\n   * @returns A version of the `target` processed by the listeners.\n   * @template Target  The type of the target.\n   * @template Args    The type of the parameters to send to the reducers/listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', async (target, arg0) => {\n   *     const data = await fetch(`https://api.example.com/${arg0}`);\n   *     target.push(data);\n   *     return target;\n   *   });\n   *   const result = await events.reduce('event', [], 'Hello');\n   *   // result would be a list of data fetched from the API.\n   *\n   */\n  async reduce<Target, Args extends GenericParams>(\n    event: string | string[],\n    target: Target,\n    ...args: Args\n  ): Promise<Target> {\n    const events = Array.isArray(event) ? event : [event];\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const result = await events.reduce<Promise<Target>>(\n      (eventAcc, name) =>\n        eventAcc.then((eventCurrent) => {\n          const subscribers = this.getSubscribers(name);\n          return subscribers.reduce(\n            (subAcc, subscriber) =>\n              subAcc.then((subCurrent) => {\n                let useCurrent;\n                if (Array.isArray(subCurrent)) {\n                  useCurrent = subCurrent.slice();\n                } else if (typeof subCurrent === 'object') {\n                  useCurrent = { ...subCurrent };\n                } else {\n                  useCurrent = subCurrent;\n                }\n\n                const nextStep = subscriber(...[useCurrent, ...args]);\n                if ('once' in subscriber) {\n                  toClean.push({\n                    event: name,\n                    listener: subscriber,\n                  });\n                }\n\n                return nextStep;\n              }),\n            Promise.resolve(eventCurrent),\n          );\n        }),\n      Promise.resolve(target),\n    );\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n\n    return result;\n  }\n  /**\n   * Synchronously reduces a target using an event. It's like emit, but the events\n   * listener return a modified (or not) version of the `target`.\n   *\n   * @param event   An event name or a list of them.\n   * @param target  The variable to reduce with the reducers/listeners.\n   * @param args    A list of parameters to send to the reducers/listeners.\n   * @returns A version of the `target` processed by the listeners.\n   * @template Target  The type of the target.\n   * @template Args    The type of the parameters to send to the reducers/listeners.\n   * @example\n   *\n   *   const events = new EventsHub();\n   *   events.on('event', (target, arg0) => {\n   *     target.push(arg0);\n   *     return target;\n   *   });\n   *   events.reduce('event', [], 'Hello'); // returns ['Hello']\n   *\n   */\n  reduceSync<Target, ReducerArgs extends GenericParams>(\n    event: string | string[],\n    target: Target,\n    ...args: ReducerArgs\n  ): Target {\n    const events = Array.isArray(event) ? event : [event];\n    const toClean: { event: string; listener: GenericFn }[] = [];\n    const result = events.reduce((eventAcc, name) => {\n      const subscribers = this.getSubscribers(name);\n      return subscribers.reduce((subAcc, subscriber) => {\n        let useCurrent;\n        if (Array.isArray(subAcc)) {\n          useCurrent = subAcc.slice();\n        } else if (typeof subAcc === 'object') {\n          useCurrent = { ...subAcc };\n        } else {\n          useCurrent = subAcc;\n        }\n\n        const nextStep = subscriber(...[useCurrent, ...args]);\n        if ('once' in subscriber) {\n          toClean.push({\n            event: name,\n            listener: subscriber,\n          });\n        }\n\n        return nextStep;\n      }, eventAcc);\n    }, target);\n\n    toClean.forEach((info) => this.off(info.event, info.listener));\n    return result;\n  }\n}\n/**\n * Shorthand for `new EventsHub()`.\n *\n * @returns A new instance of {@link EventsHub}.\n */\nexport const eventsHub = () => new EventsHub();\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@homer0/events-hub",
+  "description": "A simple implementation of a pubsub service for handling events",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/homer0/packages.git",
+    "directory": "packages/public/events-hub"
+  },
+  "author": "Leonardo Apiwan (@homer0) <me@homer0.com>",
+  "license": "MIT",
+  "keywords": [
+    "events",
+    "pubsub",
+    "utility",
+    "wootils",
+    "javascript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
+  "devDependencies": {
+    "@types/jest": "^28.1.4",
+    "jest": "^28.1.2",
+    "ts-jest": "^28.0.5",
+    "tsup": "^6.1.3",
+    "typescript": "^4.7.4"
+  },
+  "engine-strict": true,
+  "engines": {
+    "node": ">=14"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "test": "jest -c ./.jestrc.js",
+    "types:check": "tsc --noEmit && tsc --noEmit --project ./tests/tsconfig.json",
+    "build": "tsup src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "gitHead": "835d84ced485240f90c9c9173b5fcb53346bf264"
+}