@design.estate/dees-comms 1.0.32 → 1.1.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@design.estate/dees-comms',
-    version: '1.0.32',
+    version: '1.1.1',
     description: 'A communications module for enabling DOM-based messaging and synchronization across browser tabs and workers.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLCtHQUErRztDQUM3SCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLCtHQUErRztDQUM3SCxDQUFBIn0=

package/dist_ts/dees-comms.classes.deescomms.d.ts

@@ -1,12 +1,43 @@
 import * as plugins from './dees-comms.plugins.js';
+export interface IDeesCommsOptions {
+    /**
+     * The channel this instance talks on. Instances hear each other only when
+     * they use the same name, in any tab, frame or worker of the same origin.
+     * Defaults to `DeesComms.defaultChannelName`, the channel every instance
+     * used before names existed.
+     */
+    channelName?: string;
+}
+/**
+ * Receives the payload of one typed event, and the event itself.
+ */
+export type TDeesCommsEventHandler<T extends plugins.typedrequestInterfaces.ITypedEvent<unknown>> = (payloadArg: T['payload'], eventArg: T) => void | Promise<void>;
+export interface IDeesCommsSubscription {
+    /**
+     * Stops this subscription. An event that is being delivered right now does
+     * not reach it any more; calling it again does nothing.
+     */
+    unsubscribe(): void;
+}
 /**
  * a comm class for client side communication between workers and tabs.
  */
 export declare class DeesComms {
-    private broadcastChannel;
+    /**
+     * The channel of every instance that is not given a name. Code that talks
+     * to other code on it, like a service worker and its pages, keeps working
+     * unchanged; an application gives its own messages a name of its own.
+     */
+    static readonly defaultChannelName = "dees-comms";
+    readonly channelName: string;
+    private readonly channel;
+    private readonly eventHandlers;
+    private hasTypedHandlers;
+    private closed;
+    private closing;
     typedrouter: plugins.typedrequest.TypedRouter<plugins.typedrequestInterfaces.ITypedRequest>;
     typedtarget: plugins.typedrequest.TypedTarget;
-    constructor();
+    constructor(optionsArg?: IDeesCommsOptions);
     /**
      * creates a typedrequest with this classes postMessage as postMethod
      */
@@ -19,4 +50,33 @@ export declare class DeesComms {
      * subscribe to messages
      */
     createTypedHandler<T extends plugins.typedrequestInterfaces.ITypedRequest>(methodArg: T['method'], handlerFunction: plugins.typedrequest.THandlerFunction<T>): Promise<void>;
+    /**
+     * Sends a typed event to every other instance on this channel and expects
+     * no answer. The instance that sends it does not receive it; any other
+     * instance on the same channel does, in this context or another one.
+     */
+    broadcast<T extends plugins.typedrequestInterfaces.ITypedEvent<unknown>>(nameArg: T['name'], payloadArg: T['payload']): Promise<void>;
+    /**
+     * Calls the handler for every typed event of that name another instance
+     * broadcasts on this channel. Handlers run in the order they subscribed; one
+     * that throws or rejects is reported and does not keep the others from
+     * running.
+     */
+    subscribe<T extends plugins.typedrequestInterfaces.ITypedEvent<unknown>>(nameArg: T['name'], handlerArg: TDeesCommsEventHandler<T>): IDeesCommsSubscription;
+    /**
+     * Closes the channel. Nothing is received from then on, every subscription
+     * ends, and sending, broadcasting or subscribing throws. A typed request
+     * still waiting for its response when the channel closes cannot receive it
+     * and ends with its own timeout. Closing again does nothing.
+     */
+    close(): Promise<void>;
+    /**
+     * In Node.js an instance keeps its process alive while something listens on
+     * it, as a MessagePort with a message listener does: a subscription, or a
+     * typed handler it created. One nobody listens on lets the process end.
+     */
+    private holdProcessWhileListened;
+    private assertOpen;
+    private receive;
+    private dispatch;
 }

package/dist_ts/dees-comms.classes.deescomms.js

@@ -1,34 +1,103 @@
 import * as plugins from './dees-comms.plugins.js';
-let BroadcastChannel = globalThis.BroadcastChannel;
-if (!BroadcastChannel) {
-    BroadcastChannel = plugins.BroadCastChannelPolyfill;
-}
+const isProcessHolding = (channelArg) => 'ref' in channelArg &&
+    typeof channelArg.ref === 'function' &&
+    'unref' in channelArg &&
+    typeof channelArg.unref === 'function';
+/**
+ * Opens a channel that hands every message it receives to `receiveArg` as the
+ * message itself: the platform's BroadcastChannel delivers a MessageEvent, the
+ * polyfill delivers the message.
+ */
+const openChannel = (nameArg, receiveArg) => {
+    if (typeof globalThis.BroadcastChannel === 'function') {
+        const channel = new globalThis.BroadcastChannel(nameArg);
+        channel.onmessage = (eventArg) => {
+            receiveArg(eventArg.data);
+        };
+        const processHolding = isProcessHolding(channel) ? channel : null;
+        // an open channel alone does not keep a Node.js process running
+        processHolding?.unref();
+        return {
+            post: async (messageArg) => {
+                channel.postMessage(messageArg);
+            },
+            close: async () => {
+                channel.close();
+            },
+            holdProcess: (holdArg) => {
+                if (holdArg) {
+                    processHolding?.ref();
+                }
+                else {
+                    processHolding?.unref();
+                }
+            },
+        };
+    }
+    const channel = new plugins.BroadCastChannelPolyfill(nameArg);
+    channel.onmessage = (messageArg) => {
+        receiveArg(messageArg);
+    };
+    return {
+        post: (messageArg) => channel.postMessage(messageArg),
+        close: () => channel.close(),
+        // the polyfill stands in only where the platform has no channel, which
+        // Node.js always has
+        holdProcess: () => undefined,
+    };
+};
+const isObject = (valueArg) => typeof valueArg === 'object' && valueArg !== null;
+// `Object.hasOwn` is younger than some of the browsers the polyfill serves
+const hasOwn = (objectArg, keyArg) => Object.prototype.hasOwnProperty.call(objectArg, keyArg);
+/**
+ * The event a received message carries: `null` for a message that is no
+ * event, `'malformed'` for an envelope without a well-formed event in it.
+ */
+const eventOf = (messageArg) => {
+    if (!isObject(messageArg) || !hasOwn(messageArg, 'deesCommsEvent')) {
+        return null;
+    }
+    const event = messageArg.deesCommsEvent;
+    if (!isObject(event) ||
+        typeof event.name !== 'string' ||
+        typeof event.uniqueEventId !== 'string' ||
+        !hasOwn(event, 'payload')) {
+        return 'malformed';
+    }
+    return { name: event.name, uniqueEventId: event.uniqueEventId, payload: event.payload };
+};
+const createEventId = () => {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+    return Array.from(bytes, (byteArg) => byteArg.toString(16).padStart(2, '0')).join('');
+};
 /**
  * a comm class for client side communication between workers and tabs.
  */
 export class DeesComms {
+    /**
+     * The channel of every instance that is not given a name. Code that talks
+     * to other code on it, like a service worker and its pages, keeps working
+     * unchanged; an application gives its own messages a name of its own.
+     */
+    static { this.defaultChannelName = 'dees-comms'; }
     // receiving messages
-    constructor() {
-        this.broadcastChannel = new BroadcastChannel('dees-comms');
+    constructor(optionsArg = {}) {
+        this.eventHandlers = new Map();
+        this.hasTypedHandlers = false;
+        this.closed = false;
+        this.closing = null;
         // sending messages
         this.typedrouter = new plugins.typedrequest.TypedRouter();
         this.typedtarget = new plugins.typedrequest.TypedTarget({
             postMethodWithTypedRouter: async (messageArg) => {
-                this.postMessage(messageArg);
+                await this.postMessage(messageArg);
             },
             typedRouterRef: this.typedrouter,
         });
-        this.broadcastChannel.onmessage = async (eventArg) => {
-            const message = eventArg.method ? eventArg : eventArg.data;
-            // Skip hooks for broadcast-received messages to prevent infinite loops
-            // when traffic logging hooks are set up globally
-            const response = await this.typedrouter.routeAndAddResponse(message, {
-                skipHooks: true,
-            });
-            if (response && !response.error) {
-                this.postMessage(response);
-            }
-        };
+        this.channelName = optionsArg.channelName ?? DeesComms.defaultChannelName;
+        this.channel = openChannel(this.channelName, (messageArg) => {
+            void this.receive(messageArg);
+        });
     }
     /**
      * creates a typedrequest with this classes postMessage as postMethod
@@ -41,13 +110,134 @@ export class DeesComms {
      * posts a typedrequestmessage
      */
     async postMessage(messageArg) {
-        this.broadcastChannel.postMessage(messageArg);
+        this.assertOpen();
+        await this.channel.post(messageArg);
     }
     /**
      * subscribe to messages
      */
     async createTypedHandler(methodArg, handlerFunction) {
         this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler(methodArg, handlerFunction));
+        this.hasTypedHandlers = true;
+        this.holdProcessWhileListened();
+    }
+    /**
+     * Sends a typed event to every other instance on this channel and expects
+     * no answer. The instance that sends it does not receive it; any other
+     * instance on the same channel does, in this context or another one.
+     */
+    async broadcast(nameArg, payloadArg) {
+        const message = {
+            deesCommsEvent: {
+                name: nameArg,
+                uniqueEventId: createEventId(),
+                payload: payloadArg,
+            },
+        };
+        await this.postMessage(message);
+    }
+    /**
+     * Calls the handler for every typed event of that name another instance
+     * broadcasts on this channel. Handlers run in the order they subscribed; one
+     * that throws or rejects is reported and does not keep the others from
+     * running.
+     */
+    subscribe(nameArg, handlerArg) {
+        this.assertOpen();
+        // the name is the contract: what arrives under it is taken as its type,
+        // as a typed handler takes the request of its method
+        const handler = (payloadArg, eventArg) => handlerArg(payloadArg, eventArg);
+        let handlers = this.eventHandlers.get(nameArg);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(nameArg, handlers);
+        }
+        handlers.add(handler);
+        this.holdProcessWhileListened();
+        return {
+            unsubscribe: () => {
+                const current = this.eventHandlers.get(nameArg);
+                if (!current) {
+                    return;
+                }
+                current.delete(handler);
+                if (current.size === 0) {
+                    this.eventHandlers.delete(nameArg);
+                    this.holdProcessWhileListened();
+                }
+            },
+        };
+    }
+    /**
+     * Closes the channel. Nothing is received from then on, every subscription
+     * ends, and sending, broadcasting or subscribing throws. A typed request
+     * still waiting for its response when the channel closes cannot receive it
+     * and ends with its own timeout. Closing again does nothing.
+     */
+    async close() {
+        if (!this.closing) {
+            this.closed = true;
+            this.eventHandlers.clear();
+            this.closing = this.channel.close();
+        }
+        await this.closing;
+    }
+    /**
+     * In Node.js an instance keeps its process alive while something listens on
+     * it, as a MessagePort with a message listener does: a subscription, or a
+     * typed handler it created. One nobody listens on lets the process end.
+     */
+    holdProcessWhileListened() {
+        if (this.closed) {
+            return;
+        }
+        this.channel.holdProcess(this.hasTypedHandlers || this.eventHandlers.size > 0);
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new Error(`DeesComms channel "${this.channelName}" is closed`);
+        }
+    }
+    async receive(messageArg) {
+        if (this.closed) {
+            return;
+        }
+        const event = eventOf(messageArg);
+        if (event === 'malformed') {
+            console.log('DeesComms received a malformed event');
+            return;
+        }
+        if (event) {
+            this.dispatch(event);
+            return;
+        }
+        // Skip hooks for broadcast-received messages to prevent infinite loops
+        // when traffic logging hooks are set up globally. The router validates
+        // the shape of what it is given.
+        const response = await this.typedrouter.routeAndAddResponse(messageArg, { skipHooks: true });
+        if (response && !response.error && !this.closed) {
+            await this.postMessage(response);
+        }
+    }
+    dispatch(eventArg) {
+        const handlers = this.eventHandlers.get(eventArg.name);
+        if (!handlers) {
+            return;
+        }
+        for (const handler of [...handlers]) {
+            // a handler that closed the channel ends the delivery, and one an
+            // earlier handler unsubscribed is not called any more
+            if (this.closed) {
+                return;
+            }
+            if (!handlers.has(handler)) {
+                continue;
+            }
+            void (async () => handler(eventArg.payload, eventArg))().catch((errorArg) => {
+                // the event's name and the failure, never its payload
+                console.error(`DeesComms: a handler of the event "${eventArg.name}" failed`, errorArg);
+            });
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dees-comms.classes.deescomms.js","sourceRoot":"","sources":["../ts/dees-comms.classes.deescomms.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design.estate/dees-comms",
-  "version": "1.0.32",
+  "version": "1.1.1",
   "private": false,
   "description": "A communications module for enabling DOM-based messaging and synchronization across browser tabs and workers.",
   "main": "dist_ts/index.js",
@@ -9,11 +9,11 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsbundle": "^2.13.0",
-    "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^3.6.7",
-    "@types/node": "^26.1.1"
+    "@git.zone/tsbuild": "^5.0.0",
+    "@git.zone/tsbundle": "^3.0.0",
+    "@git.zone/tsrun": "^3.0.1",
+    "@git.zone/tstest": "^6.3.2",
+    "@types/node": "^26.6.2"
   },
   "dependencies": {
     "@api.global/typedrequest": "^8.0.3",

package/readme.md

@@ -1,6 +1,6 @@
 # @design.estate/dees-comms
 
-a comms module for communicating within the DOM
+Typed messaging between the tabs, frames and workers of one origin over a BroadcastChannel: typed requests that expect an answer, and typed events that do not.
 
 ## Issue Reporting and Security
 
@@ -8,113 +8,114 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 
 ## Install
 
-To integrate `@design.estate/dees-comms` into your project, run the following command in your terminal:
-
 ```bash
 pnpm add @design.estate/dees-comms
 ```
 
-This will add the package to your project dependencies. 
-
 ## Usage
 
-`@design.estate/dees-comms` facilitates communication within the DOM, especially between various workers and tabs in client-side JavaScript. Using TypeScript and the provided ESM syntax will enhance your development experience with better intellisense support and type safety.
+### Channels
+
+Every `DeesComms` instance talks on one BroadcastChannel. Instances hear each other only when they use the same channel name, in any tab, frame or worker of the same origin.
+
+```typescript
+import { DeesComms } from '@design.estate/dees-comms';
+
+// the default channel, 'dees-comms'
+const comms = new DeesComms();
+
+// a channel of this application's own
+const appComms = new DeesComms({ channelName: 'my-app' });
+
+console.log(DeesComms.defaultChannelName); // 'dees-comms'
+console.log(appComms.channelName); // 'my-app'
+```
+
+An instance created without a name uses `DeesComms.defaultChannelName`, the channel every instance used before names existed. Other packages talk on it: `DomTools` of `@design.estate/dees-domtools` opens an instance on it, and the service worker of `@api.global/typedserver` exchanges its messages with its pages there. Give your application's messages a channel of their own, so that they neither reach nor disturb that traffic.
+
+The platform's `BroadcastChannel` is used wherever there is one (browsers, workers, Node.js); elsewhere the [`broadcast-channel`](https://www.npmjs.com/package/broadcast-channel) package stands in for it.
 
-### Setting Up
+### Typed requests
 
-First, make sure to import the module in your TypeScript file:
+A typed request goes to every other instance on the channel; an instance with a handler for its method answers it.
 
 ```typescript
 import { DeesComms } from '@design.estate/dees-comms';
+import type { ITypedRequest } from '@api.global/typedrequest-interfaces';
 
-interface IMyMessage {
-  method: 'myMethod';
+interface IGreetRequest extends ITypedRequest {
+  method: 'greet';
   request: {
-    someData: string;
+    name: string;
   };
   response: {
     reply: string;
   };
 }
-```
 
-### Initializing the Communication Module
-
-Create an instance of the `DeesComms` class to start using the module. This instance will act as the central communication hub in your application.
+// in one tab or worker
+const answering = new DeesComms({ channelName: 'my-app' });
+answering.createTypedHandler<IGreetRequest>('greet', async (request) => {
+  return { reply: `Hello ${request.name}, nice to meet you!` };
+});
 
-```typescript
-const myDeesComms = new DeesComms();
+// in another one
+const asking = new DeesComms({ channelName: 'my-app' });
+const response = await asking.createTypedRequest<IGreetRequest>('greet').fire({ name: 'Alice' });
+console.log(response.reply); // 'Hello Alice, nice to meet you!'
 ```
 
-### Sending Messages
-
-To send messages, you'll need to create a typed request. Let's assume we are sending a message that requires a response:
+`postMessage()` posts a typed request object as it is; `typedrouter` and `typedtarget` are the `@api.global/typedrequest` router and target the instance routes with.
 
-```typescript
-// Creating a typed request
-const myTypedRequest = myDeesComms.createTypedRequest<IMyMessage>('myMethod');
+### Typed events
 
-// Firing the request
-const response = await myTypedRequest.fire({
-  someData: 'Hello, World!',
-});
-console.log('Received response:', response.reply);
-```
-
-### Receiving and Handling Messages
-
-To handle incoming messages, you need to define handlers for the types of messages you expect to receive. 
+A typed event is sent to every other instance on the channel and expects no answer. It is declared as an `ITypedEvent` of `@api.global/typedrequest-interfaces`: its `name` is the contract, its `payload` is what travels.
 
 ```typescript
-// Define the handler for the 'myMethod' message
-myDeesComms.createTypedHandler<IMyMessage>('myMethod', async (request) => {
-  console.log('Message received:', request.someData);
-  
-  // Process the incoming message...
-  
-  // Return a response (if needed)
-  return {
-    reply: 'Message received loud and clear!'
+import { DeesComms } from '@design.estate/dees-comms';
+import type { ITypedEvent } from '@api.global/typedrequest-interfaces';
+
+interface ISettingsChangedEvent extends ITypedEvent<{ section: string }> {
+  name: 'settingsChanged';
+  uniqueEventId: string;
+  payload: {
+    section: string;
   };
+}
+
+// in every tab that has to follow
+const listening = new DeesComms({ channelName: 'my-app' });
+const subscription = listening.subscribe<ISettingsChangedEvent>('settingsChanged', (payload, event) => {
+  console.log(`settings changed in ${payload.section}`, event.uniqueEventId);
 });
-```
 
-### Communication Between Tabs or Workers
+// in the tab where it happened
+const telling = new DeesComms({ channelName: 'my-app' });
+await telling.broadcast<ISettingsChangedEvent>('settingsChanged', { section: 'profile' });
 
-`@design.estate/dees-comms` uses the Broadcast Channel API and a polyfill for environments where it's not available, enabling seamless communication between different contexts like tabs, iframes, or web workers.
+// later
+subscription.unsubscribe();
+```
 
-### Complete Example
+- The instance that broadcasts an event does not receive it; every other instance on the channel does, in the same context or another one.
+- `broadcast()` gives every event a new `uniqueEventId`.
+- Handlers of one name run in the order they subscribed. A handler that throws or rejects is reported with `console.error`, naming the event and the error but never the payload, and does not keep the others from running. A handler that an earlier one unsubscribes during the same event is not called for it.
+- Events and typed requests stay apart: an event never reaches a typed handler, and a typed request never reaches a subscription, whatever their names.
+- An instance of 1.0.32 routes every message it receives as a typed request; on the platform's own BroadcastChannel, `@api.global/typedrequest` 8 then logs `TypedRouter received a malformed request DTO` for every event. That is one more reason to broadcast on a channel of your application's own.
 
-Putting it all together, let's create a small application that sends a message and listens for a response:
+### Closing
 
 ```typescript
-import { DeesComms } from '@design.estate/dees-comms';
-
-interface IGreetRequest {
-  method: 'greet';
-  request: {
-    name: string;
-  };
-  response: {
-    reply: string;
-  };
-}
+await comms.close();
+```
 
-const appDeesComms = new DeesComms();
+A closed instance receives nothing: its subscriptions end and its typed handlers are no longer asked. `postMessage()`, `broadcast()` and the typed requests it fires reject, and `subscribe()` throws. A typed request that is still waiting for its response when the channel closes cannot receive it and ends with its own timeout. Closing again does nothing.
 
-// Setting up the listener
-appDeesComms.createTypedHandler<IGreetRequest>('greet', async (request) => {
-  console.log(`Greetings received from ${request.name}`);
-  return { reply: `Hello ${request.name}, nice to meet you!` };
-});
+In Node.js an instance keeps the process alive only while something listens on it, as a `MessagePort` with a message listener does: while it has a subscription, or once it has created a typed handler. An instance nobody listens on, such as the one `@design.estate/dees-domtools` opens on import, lets the process end. An unsubscribed or closed instance lets it end too, so close every instance with a typed handler that a test or a script opens. In browsers and workers nothing changes.
 
-// Sending a greeting message
-const greetRequest = appDeesComms.createTypedRequest<IGreetRequest>('greet');
-const response = await greetRequest.fire({ name: 'Alice' });
-console.log(response.reply); // Expected output: "Hello Alice, nice to meet you!"
-```
+### What travels
 
-This module provides a powerful and flexible way to handle communications within the DOM, leveraging modern JavaScript features and patterns. The usage of TypeScript ensures type safety and enhances code understandability and maintainability.
+Requests, responses and events are copied with the structured clone algorithm, so they carry data, not functions or class instances. A BroadcastChannel is confined to its origin, but every script of that origin can listen on a channel whose name it knows: send no secrets, and nothing that identifies a person, on it.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@design.estate/dees-comms',
-  version: '1.0.32',
+  version: '1.1.1',
   description: 'A communications module for enabling DOM-based messaging and synchronization across browser tabs and workers.'
 }