@vandeurenglenn/little-pubsub 1.5.1 → 1.5.2

package/README.md

@@ -1,141 +1,159 @@
-# little-pubsub
-
-> Small publish & subscribe class
-
-## INSTALL
-
-#### npm
-
-```sh
-npm i --save @vandeurenglenn/little-pubsub
-```
-
-## USAGE
-
-```js
-import PubSub from '@vandeurenglenn/little-pubsub'
-const pubsub = new PubSub()
-```
-
-## Breaking Changes
-
-### v1.5.0
-
-`subscribe[context]` & `unsubscribe[context]` -> `subscribe[options({keepValue, context})]`
-
-```js
-// before
-pusbub.subscribe(topic, handler, context)
-
-// now
-pusbub.subscribe(topic, handler, { context })
-```
-
-## Example
-
-```js
-import PubSub from '@vandeurenglenn/little-pubsub'
-const pubsub = new PubSub()
-
-pubsub.subscribe('event', (value) => {
-  console.log(value)
-})
-
-pubsub.publish('event', 'hello')
-// always runs handler
-// (can use to overide littlePubsub.verbose setting without changing the behavior of the rest)
-pubsub.publishVerbose('event', 'hello')
-
-pubsub.unsubscribe('event', (value) => {
-  console.log(value)
-})
-
-pubsub.hasSubscribers('event')
-
-await pubsub.once('event')
-```
-
-## API
-
-### pubsub([options])
-
-`verbose`: when false only fires after value change<br>
-
-```js
-pubsub = new PubSub({
-  verbose: false // default: true
-})
-```
-
-#### subscribe
-
-`name`: name of the channel to subscribe to<br>
-`handler`: method<br>
-`options`: { context, keepValue }<br>
-
-subscribing to an event will also return it's initial value
-
-```js
-pubsub.subscribe('event-name', (data) => {
-  console.log(data)
-})
-```
-
-#### unsubscribe
-
-`name`: name of the channel to unsubscribe<br>
-`handler`: method<br>
-`options`: { context, keepValue }<br>
-
-```js
-pubsub.unsubscribe(
-  'event-name',
-  (data) => {
-    console.log(data)
-  },
-  { keepValue: false } // default
-)
-```
-
-#### publish
-
-`name`: name of the channel to publish to<br>
-`handler`: method<br>
-`verbose`: boolean<br>
-
-```js
-pubsub.publish('event-name', 'data')
-```
-
-#### publish
-
-`name`: name of the channel to publish to<br>
-`handler`: method<br>
-
-```js
-pubsub.publishVerbose('event-name', 'data')
-```
-
-#### once
-
-`name`: name of the channel to get the value from<br>
-
-```js
-pubsub.getValue('event-name')
-```
-
-#### once
-
-`name`: name of the channel to publish to<br>
-
-```js
-await pubsub.once('event-name')
-```
-
-#### hasSubscribers
-
-`name`: name of the channel to publish to<br>
-
-```js
-pubsub.hasSubscribers('event-name')
-```
+# little-pubsub
+
+> Small publish & subscribe class
+
+## INSTALL
+
+#### npm
+
+```sh
+npm i --save @vandeurenglenn/little-pubsub
+```
+
+## USAGE
+
+```js
+import PubSub from '@vandeurenglenn/little-pubsub'
+const pubsub = new PubSub()
+```
+
+## Breaking Changes
+
+### v1.5.0
+
+`subscribe[context]` & `unsubscribe[context]` -> `subscribe[options({keepValue, context})]`
+
+```js
+// before
+pusbub.subscribe(topic, handler, context)
+
+// now
+pusbub.subscribe(topic, handler, { context })
+```
+
+## Example
+
+```js
+import PubSub from '@vandeurenglenn/little-pubsub'
+const pubsub = new PubSub()
+
+pubsub.subscribe('event', (value) => {
+  console.log(value)
+})
+
+pubsub.publish('event', 'hello')
+// always runs handler
+// (can use to overide littlePubsub.verbose setting without changing the behavior of the rest)
+pubsub.publishVerbose('event', 'hello')
+
+pubsub.unsubscribe('event', (value) => {
+  console.log(value)
+})
+
+pubsub.hasSubscribers('event')
+
+await pubsub.once('event')
+```
+
+## API
+
+### pubsub(verbose?)
+
+`verbose`: when false only fires after value change (default: false)<br>
+
+```js
+const pubsub = new PubSub() // verbose defaults to false
+const pubsub = new PubSub(true) // always trigger handlers
+```
+
+#### subscribe
+
+`name`: name of the channel to subscribe to<br>
+`handler`: method<br>
+`options`: { context }<br>
+
+Subscribing to an event returns an unsubscribe function. If value already exists, handler is called immediately.
+
+```js
+const unsubscribe = pubsub.subscribe('event-name', (data) => {
+  console.log(data)
+})
+
+// Later: clean unsubscribe
+unsubscribe()
+```
+
+#### unsubscribe
+
+`name`: name of the channel to unsubscribe<br>
+`handler`: method<br>
+`options`: { context, keepValue }<br>
+
+```js
+pubsub.unsubscribe(
+  'event-name',
+  (data) => {
+    console.log(data)
+  },
+  { keepValue: false } // default
+)
+```
+
+#### publish
+
+`name`: name of the channel to publish to<br>
+`handler`: method<br>
+`verbose`: boolean<br>
+
+```js
+pubsub.publish('event-name', 'data')
+```
+
+#### publish
+
+`name`: name of the channel to publish to<br>
+`handler`: method<br>
+
+```js
+pubsub.publishVerbose('event-name', 'data')
+```
+
+#### once
+
+`name`: name of the channel to get the value from<br>
+
+```js
+pubsub.getValue('event-name')
+```
+
+#### once
+
+`name`: name of the channel to publish to<br>
+
+```js
+await pubsub.once('event-name')
+```
+
+#### hasSubscribers
+
+`name`: name of the channel to check<br>
+
+```js
+pubsub.hasSubscribers('event-name') // true or false
+```
+
+#### subscriberCount
+
+`name`: name of the channel to count<br>
+
+```js
+pubsub.subscriberCount('event-name') // number of handlers
+```
+
+#### clear
+
+Removes all subscribers and values.
+
+```js
+pubsub.clear()
+```

package/index.d.ts

@@ -1,26 +1,33 @@
+export type Handler<T = any> = (value: T, oldValue?: T) => void;
+export interface HandlerEntry<T = any> {
+    original: Handler<T>;
+    bound: Handler<T>;
+}
+export interface Subscriber<T = any> {
+    value?: T;
+    handlers: HandlerEntry<T>[];
+}
+export interface SubscribeOptions {
+    context?: object;
+}
+export interface UnsubscribeOptions {
+    keepValue?: boolean;
+    context?: object;
+}
+export interface OnceOptions extends UnsubscribeOptions {
+    timeout?: number;
+}
 export default class LittlePubSub {
-    subscribers: {
-        [index: string]: {
-            value?: any;
-            handlers?: Function[];
-        };
-    };
+    subscribers: Map<string, Subscriber>;
     verbose: boolean;
     constructor(verbose?: boolean);
-    _handleContext(handler: Function, context?: Function): Function;
     hasSubscribers(event: string): boolean;
-    getValue(event: string): any;
-    subscribe(event: string, handler: Function, options?: {
-        context?: Function;
-    }): void;
-    unsubscribe(event: string, handler: Function, options?: {
-        keepValue?: boolean;
-        context?: Function;
-    }): void;
-    publish(event: string, value: any, verbose?: boolean): void;
-    publishVerbose(event: string, value: any): void;
-    once(event: string, options?: {
-        keepValue?: boolean;
-        context?: Function;
-    }): Promise<any>;
+    subscriberCount(event: string): number;
+    clear(): void;
+    getValue<T = any>(event: string): T | undefined;
+    subscribe<T = any>(event: string, handler: Handler<T>, options?: SubscribeOptions): () => void;
+    unsubscribe<T = any>(event: string, handler: Handler<T>, options?: UnsubscribeOptions): void;
+    publish<T = any>(event: string, value: T, verbose?: boolean): void;
+    publishVerbose<T = any>(event: string, value: T): void;
+    once<T = any>(event: string, options?: OnceOptions): Promise<T>;
 }

package/index.js

@@ -1,56 +1,71 @@
 export default class LittlePubSub {
-    subscribers = {};
+    subscribers = new Map();
     verbose;
     constructor(verbose) {
-        this.verbose = verbose;
-    }
-    _handleContext(handler, context) {
-        if (typeof context === 'undefined') {
-            context = handler;
-        }
-        return context;
+        this.verbose = verbose ?? false;
     }
     hasSubscribers(event) {
-        return this.subscribers[event] ? true : false;
+        return this.subscribers.has(event);
+    }
+    subscriberCount(event) {
+        return this.subscribers.get(event)?.handlers.length ?? 0;
+    }
+    clear() {
+        this.subscribers.clear();
     }
     getValue(event) {
-        if (this.subscribers[event])
-            return this.subscribers[event].value;
-        return undefined;
+        return this.subscribers.get(event)?.value;
     }
     subscribe(event, handler, options) {
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = { handlers: [], value: undefined };
-        const context = this._handleContext(handler, options?.context);
-        const _handler = handler.bind(context);
-        this.subscribers[event].handlers.push(_handler);
-        if (this.subscribers[event].value !== undefined)
-            _handler(this.subscribers[event].value, undefined);
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        // Only bind if context is provided
+        const context = options?.context;
+        const boundHandler = context
+            ? handler.bind(context)
+            : handler;
+        subscriber.handlers.push({ original: handler, bound: boundHandler });
+        // Call handler immediately if value already exists
+        if (subscriber.value !== undefined) {
+            boundHandler(subscriber.value, undefined);
+        }
+        // Return unsubscribe function
+        return () => this.unsubscribe(event, handler, options);
     }
     unsubscribe(event, handler, options) {
-        if (!options)
-            options = { keepValue: false };
-        if (!this.hasSubscribers(event))
+        const subscriber = this.subscribers.get(event);
+        if (subscriber === undefined)
             return;
-        const context = this._handleContext(handler, options.context);
-        const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
-        this.subscribers[event].handlers.splice(index);
-        // delete event if no handlers left but supports keeping value for later use
-        // (like when unsubscribing from a value that is still needed because others might subscibe to it)
-        if (this.subscribers[event].handlers.length === 0 && !options.keepValue)
-            delete this.subscribers[event];
+        const handlers = subscriber.handlers;
+        // Find and remove handler by original reference
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            if (handlers[i].original === handler) {
+                handlers.splice(i, 1);
+                break;
+            }
+        }
+        // Delete event if no handlers left (unless keepValue is true)
+        if (handlers.length === 0 && !options?.keepValue) {
+            this.subscribers.delete(event);
+        }
     }
     publish(event, value, verbose) {
-        // always set value even when having no subscribers
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = {
-                handlers: []
-            };
-        const oldValue = this.subscribers[event]?.value;
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        const oldValue = subscriber.value;
+        // Only trigger handlers if verbose or value changed
         if (this.verbose || verbose || oldValue !== value) {
-            this.subscribers[event].value = value;
-            for (const handler of this.subscribers[event].handlers) {
-                handler(value, oldValue);
+            subscriber.value = value;
+            const handlers = subscriber.handlers;
+            const len = handlers.length;
+            for (let i = 0; i < len; i++) {
+                handlers[i].bound(value, oldValue);
             }
         }
     }
@@ -58,12 +73,21 @@ export default class LittlePubSub {
         this.publish(event, value, true);
     }
     once(event, options) {
-        return new Promise((resolve) => {
-            const cb = (value) => {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            const handler = (value) => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
                 resolve(value);
-                this.unsubscribe(event, cb, options);
+                this.unsubscribe(event, handler, options);
             };
-            this.subscribe(event, cb, options);
+            this.subscribe(event, handler, options);
+            if (options?.timeout !== undefined) {
+                timeoutId = setTimeout(() => {
+                    this.unsubscribe(event, handler, options);
+                    reject(new Error(`Timeout waiting for event "${event}"`));
+                }, options.timeout);
+            }
         });
     }
 }

package/package.json

@@ -1,36 +1,36 @@
-{
-  "name": "@vandeurenglenn/little-pubsub",
-  "version": "1.5.1",
-  "description": "Publish & Subscribe",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./index.js",
-      "types": "./index.d.ts"
-    }
-  },
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "repository": "https://github.com/vandeurenglenn/little-pubsub",
-  "author": "vandeurenglenn <vandeurenglenn@gmail.com>",
-  "license": "MIT",
-  "type": "module",
-  "private": false,
-  "scripts": {
-    "build": "npx tsc",
-    "test": "node test.js"
-  },
-  "keywords": [
-    "publish",
-    "subscribe",
-    "pubsub",
-    "once"
-  ],
-  "devDependencies": {
-    "tape": "^5.8.1",
-    "typescript": "^5.6.2"
-  }
-}
+{
+  "name": "@vandeurenglenn/little-pubsub",
+  "version": "1.5.2",
+  "description": "Publish & Subscribe",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "repository": "https://github.com/vandeurenglenn/little-pubsub",
+  "author": "vandeurenglenn <vandeurenglenn@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "private": false,
+  "scripts": {
+    "build": "npx tsc",
+    "test": "node --test test.js",
+    "benchmark": "node benchmark.js"
+  },
+  "keywords": [
+    "publish",
+    "subscribe",
+    "pubsub",
+    "once"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}