@openfin/remote-adapter 36.78.7 → 36.78.13

package/out/{backchannel-ce544f7d.js → backchannel-e240e597.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var bridge = require('./bridge-e92ef6b7.js');
+var bridge = require('./bridge-ef11968f.js');
 
 exports.eventsExports = {};
 var events = {
@@ -482,19 +482,19 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-class BackChannel extends exports.eventsExports.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' }));
-    }
+class BackChannel extends exports.eventsExports.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/backchannel.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var backchannel = require('./backchannel-ce544f7d.js');
-require('./bridge-e92ef6b7.js');
+var backchannel = require('./backchannel-e240e597.js');
+require('./bridge-ef11968f.js');
 
 
 

package/out/{bridge-e92ef6b7.js → bridge-ef11968f.js}

@@ -2,71 +2,71 @@
 
 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;
-}
+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);
-    });
+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;

package/out/bridge.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var bridge = require('./bridge-e92ef6b7.js');
+var bridge = require('./bridge-ef11968f.js');
 
 
 

package/out/constants.js

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

package/out/remote-adapter-alpha.d.ts

@@ -1,48 +1,48 @@
-import * as OpenFin from 'openfin-adapter/OpenFin';
-
-/**
- * Connect remotely to another OpenFin runtime using a WebRTC peer.
- * Returned `fin` will proxy all API calls to the "host" application.
- * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
- * If the host application already called `init` the bridge will be established immediately.
- * @param {ConnectOptions} options connect options
- * @throws If `wait` is `false` and the host application does not call `init` within a timeout
- * @returns {OpenFin.Fin<'external connection'>} `fin` API
- */
-export declare function connect(options: ConnectOptions): Promise<{
-    fin: OpenFin.Fin<'external connection'>;
-}>;
-
-export declare type ConnectOptions = {
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * If `connect` should wait for host application to call `init`, defaults to `true`.
-     */
-    wait?: boolean;
-};
-
-/**
- * Initialize a remote connection as a "host" application.
- * @param {InitOptions} options init options
- */
-export declare function init(options: InitOptions): Promise<void>;
-
-export declare type InitOptions = {
-    /**
-     * `fin` API
-     */
-    fin: OpenFin.Fin<OpenFin.EntityType>;
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * Unique identifier for the remote external connection.
-     */
-    uuid?: string;
-};
-
-export { }
+import * as OpenFin from 'openfin-adapter/OpenFin';
+
+/**
+ * Connect remotely to another OpenFin runtime using a WebRTC peer.
+ * Returned `fin` will proxy all API calls to the "host" application.
+ * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
+ * If the host application already called `init` the bridge will be established immediately.
+ * @param {ConnectOptions} options connect options
+ * @throws If `wait` is `false` and the host application does not call `init` within a timeout
+ * @returns {OpenFin.Fin<'external connection'>} `fin` API
+ */
+export declare function connect(options: ConnectOptions): Promise<{
+    fin: OpenFin.Fin<'external connection'>;
+}>;
+
+export declare type ConnectOptions = {
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * If `connect` should wait for host application to call `init`, defaults to `true`.
+     */
+    wait?: boolean;
+};
+
+/**
+ * Initialize a remote connection as a "host" application.
+ * @param {InitOptions} options init options
+ */
+export declare function init(options: InitOptions): Promise<void>;
+
+export declare type InitOptions = {
+    /**
+     * `fin` API
+     */
+    fin: OpenFin.Fin<OpenFin.EntityType>;
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * Unique identifier for the remote external connection.
+     */
+    uuid?: string;
+};
+
+export { }

package/out/remote-adapter-beta.d.ts

@@ -1,48 +1,48 @@
-import * as OpenFin from 'openfin-adapter/OpenFin';
-
-/**
- * Connect remotely to another OpenFin runtime using a WebRTC peer.
- * Returned `fin` will proxy all API calls to the "host" application.
- * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
- * If the host application already called `init` the bridge will be established immediately.
- * @param {ConnectOptions} options connect options
- * @throws If `wait` is `false` and the host application does not call `init` within a timeout
- * @returns {OpenFin.Fin<'external connection'>} `fin` API
- */
-export declare function connect(options: ConnectOptions): Promise<{
-    fin: OpenFin.Fin<'external connection'>;
-}>;
-
-export declare type ConnectOptions = {
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * If `connect` should wait for host application to call `init`, defaults to `true`.
-     */
-    wait?: boolean;
-};
-
-/**
- * Initialize a remote connection as a "host" application.
- * @param {InitOptions} options init options
- */
-export declare function init(options: InitOptions): Promise<void>;
-
-export declare type InitOptions = {
-    /**
-     * `fin` API
-     */
-    fin: OpenFin.Fin<OpenFin.EntityType>;
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * Unique identifier for the remote external connection.
-     */
-    uuid?: string;
-};
-
-export { }
+import * as OpenFin from 'openfin-adapter/OpenFin';
+
+/**
+ * Connect remotely to another OpenFin runtime using a WebRTC peer.
+ * Returned `fin` will proxy all API calls to the "host" application.
+ * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
+ * If the host application already called `init` the bridge will be established immediately.
+ * @param {ConnectOptions} options connect options
+ * @throws If `wait` is `false` and the host application does not call `init` within a timeout
+ * @returns {OpenFin.Fin<'external connection'>} `fin` API
+ */
+export declare function connect(options: ConnectOptions): Promise<{
+    fin: OpenFin.Fin<'external connection'>;
+}>;
+
+export declare type ConnectOptions = {
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * If `connect` should wait for host application to call `init`, defaults to `true`.
+     */
+    wait?: boolean;
+};
+
+/**
+ * Initialize a remote connection as a "host" application.
+ * @param {InitOptions} options init options
+ */
+export declare function init(options: InitOptions): Promise<void>;
+
+export declare type InitOptions = {
+    /**
+     * `fin` API
+     */
+    fin: OpenFin.Fin<OpenFin.EntityType>;
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * Unique identifier for the remote external connection.
+     */
+    uuid?: string;
+};
+
+export { }

package/out/remote-adapter-public.d.ts

@@ -1,48 +1,48 @@
-import * as OpenFin from 'openfin-adapter/OpenFin';
-
-/**
- * Connect remotely to another OpenFin runtime using a WebRTC peer.
- * Returned `fin` will proxy all API calls to the "host" application.
- * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
- * If the host application already called `init` the bridge will be established immediately.
- * @param {ConnectOptions} options connect options
- * @throws If `wait` is `false` and the host application does not call `init` within a timeout
- * @returns {OpenFin.Fin<'external connection'>} `fin` API
- */
-export declare function connect(options: ConnectOptions): Promise<{
-    fin: OpenFin.Fin<'external connection'>;
-}>;
-
-export declare type ConnectOptions = {
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * If `connect` should wait for host application to call `init`, defaults to `true`.
-     */
-    wait?: boolean;
-};
-
-/**
- * Initialize a remote connection as a "host" application.
- * @param {InitOptions} options init options
- */
-export declare function init(options: InitOptions): Promise<void>;
-
-export declare type InitOptions = {
-    /**
-     * `fin` API
-     */
-    fin: OpenFin.Fin<OpenFin.EntityType>;
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * Unique identifier for the remote external connection.
-     */
-    uuid?: string;
-};
-
-export { }
+import * as OpenFin from 'openfin-adapter/OpenFin';
+
+/**
+ * Connect remotely to another OpenFin runtime using a WebRTC peer.
+ * Returned `fin` will proxy all API calls to the "host" application.
+ * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
+ * If the host application already called `init` the bridge will be established immediately.
+ * @param {ConnectOptions} options connect options
+ * @throws If `wait` is `false` and the host application does not call `init` within a timeout
+ * @returns {OpenFin.Fin<'external connection'>} `fin` API
+ */
+export declare function connect(options: ConnectOptions): Promise<{
+    fin: OpenFin.Fin<'external connection'>;
+}>;
+
+export declare type ConnectOptions = {
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * If `connect` should wait for host application to call `init`, defaults to `true`.
+     */
+    wait?: boolean;
+};
+
+/**
+ * Initialize a remote connection as a "host" application.
+ * @param {InitOptions} options init options
+ */
+export declare function init(options: InitOptions): Promise<void>;
+
+export declare type InitOptions = {
+    /**
+     * `fin` API
+     */
+    fin: OpenFin.Fin<OpenFin.EntityType>;
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * Unique identifier for the remote external connection.
+     */
+    uuid?: string;
+};
+
+export { }

package/out/remote-adapter.d.ts

@@ -1,48 +1,48 @@
-import * as OpenFin from 'openfin-adapter/OpenFin';
-
-/**
- * Connect remotely to another OpenFin runtime using a WebRTC peer.
- * Returned `fin` will proxy all API calls to the "host" application.
- * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
- * If the host application already called `init` the bridge will be established immediately.
- * @param {ConnectOptions} options connect options
- * @throws If `wait` is `false` and the host application does not call `init` within a timeout
- * @returns {OpenFin.Fin<'external connection'>} `fin` API
- */
-export declare function connect(options: ConnectOptions): Promise<{
-    fin: OpenFin.Fin<'external connection'>;
-}>;
-
-export declare type ConnectOptions = {
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * If `connect` should wait for host application to call `init`, defaults to `true`.
-     */
-    wait?: boolean;
-};
-
-/**
- * Initialize a remote connection as a "host" application.
- * @param {InitOptions} options init options
- */
-export declare function init(options: InitOptions): Promise<void>;
-
-export declare type InitOptions = {
-    /**
-     * `fin` API
-     */
-    fin: OpenFin.Fin<OpenFin.EntityType>;
-    /**
-     * WebRTC peer connection.
-     */
-    rtc: RTCPeerConnection;
-    /**
-     * Unique identifier for the remote external connection.
-     */
-    uuid?: string;
-};
-
-export { }
+import * as OpenFin from 'openfin-adapter/OpenFin';
+
+/**
+ * Connect remotely to another OpenFin runtime using a WebRTC peer.
+ * Returned `fin` will proxy all API calls to the "host" application.
+ * If `wait` is `true` than `connect` will resolve once the host application calls `init`.
+ * If the host application already called `init` the bridge will be established immediately.
+ * @param {ConnectOptions} options connect options
+ * @throws If `wait` is `false` and the host application does not call `init` within a timeout
+ * @returns {OpenFin.Fin<'external connection'>} `fin` API
+ */
+export declare function connect(options: ConnectOptions): Promise<{
+    fin: OpenFin.Fin<'external connection'>;
+}>;
+
+export declare type ConnectOptions = {
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * If `connect` should wait for host application to call `init`, defaults to `true`.
+     */
+    wait?: boolean;
+};
+
+/**
+ * Initialize a remote connection as a "host" application.
+ * @param {InitOptions} options init options
+ */
+export declare function init(options: InitOptions): Promise<void>;
+
+export declare type InitOptions = {
+    /**
+     * `fin` API
+     */
+    fin: OpenFin.Fin<OpenFin.EntityType>;
+    /**
+     * WebRTC peer connection.
+     */
+    rtc: RTCPeerConnection;
+    /**
+     * Unique identifier for the remote external connection.
+     */
+    uuid?: string;
+};
+
+export { }