@openfin/remote-adapter 38.81.19 → 38.81.23

package/out/backchannel.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var require$$0 = require('events');
+var bridge = require('./bridge-ef11968f.js');
+
+class BackChannel extends require$$0.EventEmitter {
+    constructor(datachannel) {
+        super();
+        this.datachannel = datachannel;
+        this.onmessage = (message) => {
+            const data = JSON.parse(message.data);
+            this.emit(data.type, data);
+        };
+        this.send = (data) => {
+            this.datachannel.send(JSON.stringify(data));
+        };
+        this.opened = bridge.initializeMessageReceiver(datachannel, this.onmessage, () => this.emit('closed', { type: 'closed' }));
+    }
+}
+
+exports.BackChannel = BackChannel;

package/out/bridge-ef11968f.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var messageReceiver = {};
+
+Object.defineProperty(messageReceiver, "__esModule", { value: true });
+var isOpen_1 = messageReceiver.isOpen = void 0;
+function isOpen(receiver) {
+    return receiver.readyState === 'open' || receiver.readyState === 1;
+}
+isOpen_1 = messageReceiver.isOpen = isOpen;
+
+async function initializeMessageReceiver(socket, onmessage, onclose) {
+    return new Promise((resolve, reject) => {
+        socket.addEventListener('open', () => resolve());
+        socket.addEventListener('error', reject);
+        if (onmessage) {
+            socket.addEventListener('message', onmessage);
+        }
+        if (onclose) {
+            socket.addEventListener('close', onclose);
+        }
+        if (isOpen_1(socket)) {
+            resolve();
+        }
+    });
+}
+async function bridge(local, remote) {
+    const onMessage = (other) => (event) => {
+        if (isOpen_1(other)) {
+            other.send(event.data);
+        }
+    };
+    await Promise.all([
+        initializeMessageReceiver(local, onMessage(remote), () => remote.close()),
+        initializeMessageReceiver(remote, onMessage(local), () => local.close())
+    ]);
+}
+function createOpenedDataChannel(label, rtc) {
+    const datachannel = rtc.createDataChannel(label);
+    return new Promise((resolve) => {
+        const listener = () => {
+            datachannel.removeEventListener('open', listener);
+            resolve(datachannel);
+        };
+        datachannel.addEventListener('open', listener);
+    });
+}
+function waitForDataChannel(label, rtc) {
+    let resolver;
+    const dataChannelPromise = new Promise((resolve) => {
+        resolver = resolve;
+    });
+    const listener = (event) => {
+        const openListener = () => {
+            event.channel.removeEventListener('open', openListener);
+            resolver(event.channel);
+        };
+        if (event.channel.label === label) {
+            event.channel.addEventListener('open', openListener);
+            rtc.removeEventListener('datachannel', listener);
+        }
+    };
+    rtc.addEventListener('datachannel', listener);
+    return dataChannelPromise;
+}
+function promisifyOnce(emitter, eventName) {
+    return new Promise((resolve) => {
+        emitter.once(eventName, resolve);
+    });
+}
+
+exports.bridge = bridge;
+exports.createOpenedDataChannel = createOpenedDataChannel;
+exports.initializeMessageReceiver = initializeMessageReceiver;
+exports.messageReceiver = messageReceiver;
+exports.promisifyOnce = promisifyOnce;
+exports.waitForDataChannel = waitForDataChannel;

package/out/bridge.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var bridge = require('./bridge-ef11968f.js');
+
+
+
+exports.bridge = bridge.bridge;
+exports.createOpenedDataChannel = bridge.createOpenedDataChannel;
+exports.initializeMessageReceiver = bridge.initializeMessageReceiver;
+exports.promisifyOnce = bridge.promisifyOnce;
+exports.waitForDataChannel = bridge.waitForDataChannel;

package/out/constants.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const PRIMARY_NAME = 'wire';
+const SECONDARY_NAME = 'backchannel';
+const REMOTE_READY = 'remote-ready';
+const HOST_READY = 'host-ready';
+
+exports.HOST_READY = HOST_READY;
+exports.PRIMARY_NAME = PRIMARY_NAME;
+exports.REMOTE_READY = REMOTE_READY;
+exports.SECONDARY_NAME = SECONDARY_NAME;