@webqit/port-plus 0.1.0

package/src/RelayPort.js

@@ -0,0 +1,50 @@
+import { StarPort } from './StarPort.js';
+
+export class RelayPort extends StarPort {
+
+    #namespace;
+    get namespace() { return this.#namespace; }
+
+    constructor(namespace = null) {
+        super();
+        this.#namespace = namespace;
+    }
+
+    addPort(portPlus, { resolveData = null } = {}) {
+        const $resolveData = (data, ...args) => {
+            if (resolveData) return resolveData(data, ...args);
+            return data;
+        };
+
+        // Add port and forward its messages back to this relay instance
+        const unadd = super.addPort(portPlus, { enableBubbling: false });
+        const unforward = portPlus.forwardPort('*', this, { bidirectional: false, resolveData: $resolveData, namespace1: this.namespace, namespace2: this.namespace });
+
+        const messageType_ping = this.namespace
+            && `${this.namespace}:message`
+            || 'message';
+
+        // PING: joins
+        this.postMessage(
+            $resolveData({ event: 'joins' }, portPlus, this),
+            { type: messageType_ping, relayedFrom: portPlus }
+        );
+
+        const leaves = () => {
+            // PING: leaves
+            this.postMessage(
+                $resolveData({ event: 'leaves' }, portPlus, this),
+                { type: messageType_ping, relayedFrom: portPlus }
+            );
+        };
+
+        const cleanup = () => {
+            leaves();
+            unforward();
+            unadd();
+        };
+
+        portPlus.readyStateChange('close').then(cleanup);
+        return cleanup;
+    }
+}

package/src/StarPort.js

@@ -0,0 +1,74 @@
+import { MessagePortPlus, _meta, _options } from './MessagePortPlus.js';
+
+export class StarPort extends MessagePortPlus {
+
+    #ports = new Set;
+
+    get length() { return this.#ports.size; }
+
+    [Symbol.iterator]() { return this.#ports[Symbol.iterator](); }
+
+    constructor({ autoClose = true } = {}) {
+        super({ autoStart: false, postAwaitsOpen: true, autoClose });
+    }
+
+    addPort(portPlus, { enableBubbling = true } = {}) {
+        if (!(portPlus instanceof MessagePortPlus)) {
+            throw new TypeError('Port must be a WQMessagePort instance.');
+        }
+
+        if (this.#ports.has(portPlus)) return;
+        this.#ports.add(portPlus); // @ORDER: 1
+
+        const portPlusMeta = _meta(portPlus);
+
+        if (enableBubbling) {
+            if (portPlusMeta.get('parentNode')) {
+                throw new TypeError('Incoming port already has a parent node.');
+            }
+            portPlusMeta.set('parentNode', this); // @ORDER: 2
+        }
+
+        portPlus.readyStateChange('open').then(() => this.start());
+        portPlus.readyStateChange('close').then(cleanup);
+
+        const cleanup = () => {
+            if (!this.#ports.has(portPlus)) return;
+            
+            this.#ports.delete(portPlus);
+
+            if (enableBubbling
+                && portPlusMeta.get('parentNode') === this) {
+                portPlusMeta.set('parentNode', null);
+            }
+
+            if (this.#ports.size === 0
+                && _options(this).autoClose) {
+                this.close();
+            }
+        };
+
+        return cleanup;
+    }
+
+    findPort(callback) {
+        for (const portPlus of this.#ports) {
+            if (callback(portPlus)) return portPlus;
+        }
+    }
+
+    // --------
+
+    _postMessage(payload, portOptions, relayedFrom) {
+        for (const portPlus of this.#ports) {
+            if (portPlus === relayedFrom) continue;
+            portPlus.postMessage(payload, portOptions);
+        }
+    }
+
+    close(...args) {
+        for (const portPlus of this.#ports) {
+            portPlus.close?.(...args);
+        }
+    }
+}

package/src/WebSocketPort.js

@@ -0,0 +1,47 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import {
+    _meta,
+    MessagePortPlusMockPortsMixin,
+} from './MessagePortPlus.js';
+
+export class WebSocketPort extends MessagePortPlusMockPortsMixin(EventTarget) {
+
+    #ws;
+
+    constructor(ws, { autoStart = true, naturalOpen = true, postAwaitsOpen = false } = {}) {
+        super();
+        this.#ws = typeof ws === 'string' ? new WebSocket(ws) : ws;
+        
+        const portPlusMeta = _meta(this);
+        portPlusMeta.set('options', { autoStart, naturalOpen, postAwaitsOpen });
+        // Must come before upgradeEvents()
+
+        this.constructor/* IMPORTANT */.upgradeEvents(this.#ws, this);
+
+        if (naturalOpen
+            && autoStart
+            && this.#ws.readyState === WebSocket.OPEN) {
+            this.start();
+        }
+        if (this.#ws.readyState === WebSocket.CLOSED) {
+            try { this.close(); } catch(e) {}
+        }
+    }
+
+    static _hydrateMessage(portPlus, event) {
+        try {
+            let data;
+            if (typeof event.data === 'string'
+                && _isObject(data = JSON.parse(event.data))
+                && data['.wq']) {
+                Object.defineProperty(event, 'data', { value: data, configurable: true });
+                return super._hydrateMessage(portPlus, event);
+            }
+        } catch (e) {}
+        return event;
+    }
+
+    __postMessage(payload, portOptions) {
+        this.#ws.send(JSON.stringify(payload), portOptions);
+    }
+}

package/src/index.browser.js

@@ -0,0 +1,2 @@
+import * as PortPlus from './index.js';
+Object.assign(globalThis, PortPlus);

package/src/index.js

@@ -0,0 +1,7 @@
+export { BroadcastChannelPlus } from './BroadcastChannelPlus.js';
+export { MessageChannelPlus } from './MessageChannelPlus.js';
+export { MessageEventPlus } from './MessageEventPlus.js';
+export { MessagePortPlus } from './MessagePortPlus.js';
+export { RelayPort } from './RelayPort.js';
+export { StarPort } from './StarPort.js';
+export { WebSocketPort } from './WebSocketPort.js';

package/test/basic.test.js

@@ -0,0 +1,38 @@
+import { MessagePortPlus, MessageChannelPlus, WebSocketPort, BroadcastChannelPlus } from '../src/index.js';
+
+const t = new MessagePortPlus;
+
+let m, q = 3;
+
+if (q === 1) {
+    m = new MessageChannel;
+} else if (q === 2) {
+    m = { port1: new BroadcastChannel('test'), port2: new BroadcastChannel('test') };
+} else if (q === 3) {
+    m = new MessageChannelPlus({ postAwaitsOpen: true });
+    m.port1.__ = 1;
+    m.port2.__ = 2;
+} else if (q === 4) {
+    m = { port0: new BroadcastChannelPlus('test', { clientServerMode: 'client', postAwaitsOpen: true }), port1: new BroadcastChannelPlus('test', { clientServerMode: 'client', postAwaitsOpen: true }), port2: new BroadcastChannelPlus('test', { clientServerMode: 'server', postAwaitsOpen: true }) };
+    m.port0.__ = 0;
+    m.port1.__ = 1;
+    m.port2.__ = 2;
+    console.log('____________________________________');
+}
+
+
+m.port0?.addEventListener('open', () => console.log('open0'));
+m.port0?.addEventListener('close', () => console.log('close0'));
+
+m.port1.addEventListener('open', () => console.log('open1'));
+m.port1.addEventListener('close', () => console.log('close1'));
+
+m.port2.addEventListener('open', () => console.log('open2'));
+m.port2.addEventListener('close', () => console.log('close2'));
+
+m.port1.addEventListener('message', (e) => console.log('message', e.data));
+m.port2.postMessage('hello');
+
+await new Promise((r) => setTimeout(r, 3000));
+//m.port1.close();
+m.port2.close();