@openfin/core 31.74.31 → 32.75.1

package/src/api/interappbus/channel/index.js

@@ -10,24 +10,46 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Channel_connectionManager;
+var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 /* eslint-disable no-console */
-const client_1 = require("./client");
-const provider_1 = require("./provider");
+const events_1 = require("events");
+const lazy_1 = require("../../../util/lazy");
 const base_1 = require("../../base");
+const client_1 = require("./client");
 const connection_manager_1 = require("./connection-manager");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const noop = () => { };
+const provider_1 = require("./provider");
+function retryDelay(count) {
+    const interval = 500; // base delay
+    const steps = 10; // How many retries to do before incrementing the delay
+    const base = 2; // How much to multiply the previous delay by
+    const max = 30000; // max delay
+    const step = Math.floor(count / steps);
+    const delay = Math.min(max, interval * base ** step);
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve(false);
+        }, delay);
+    });
+}
 class Channel extends base_1.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
         _Channel_connectionManager.set(this, void 0);
+        _Channel_internalEmitter.set(this, new events_1.EventEmitter());
+        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.
+        _Channel_readyToConnect.set(this, new lazy_1.AsyncRetryableLazy(async () => {
+            await Promise.all([
+                this.on('disconnected', (eventPayload) => {
+                    client_1.default.handleProviderDisconnect(eventPayload);
+                }),
+                this.on('connected', (...args) => {
+                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                })
+            ]).catch(() => new Error('error setting up channel connection listeners'));
+        }));
         __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
-        this.on('disconnected', (eventPayload) => {
-            client_1.default.handleProviderDisconnect(eventPayload);
-        }).catch((e) => console.error('Error setting up a disconnected listener:', e));
     }
     async getAllChannels() {
         return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
@@ -38,79 +60,94 @@ class Channel extends base_1.EmitterBase {
     async onChannelDisconnect(listener) {
         await this.on('disconnected', listener);
     }
-    async connect(channelName, options) {
-        if (!channelName || typeof channelName !== 'string') {
-            throw new Error('Please provide a channelName string to connect to a channel.');
-        }
-        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().connect, options || {});
-        let resolver = noop;
-        let listener = noop;
-        const waitResponse = new Promise((resolve) => {
-            resolver = resolve;
-            listener = (payload) => {
-                if (channelName === payload.channelName) {
-                    this.removeListener('connected', listener);
-                    resolve(this.connect(channelName, opts));
-                }
-            };
-            this.on('connected', listener);
-        });
-        try {
-            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
-            let connectionUrl;
-            const entityType = this.wire.environment.getCurrentEntityType();
-            if (entityType === 'iframe') {
-                // @ts-expect-error
-                // TODO: type this correctly (frame types are broken)
-                connectionUrl = (await this.fin.me.getInfo()).url;
-            }
-            else if (entityType === 'window' || entityType === 'view') {
-                connectionUrl = (await this.fin.me.getInfo()).url;
-            }
-            const res = await this.wire.sendAction('connect-to-channel', {
-                channelName,
-                ...opts,
-                offer,
-                connectionUrl
+    async safeConnect(channelName, shouldWait, connectPayload) {
+        const retryInfo = { count: 0 };
+        /* eslint-disable no-await-in-loop, no-constant-condition */
+        do {
+            // setup a listener and a connected promise to await in case we connect before the channel is ready
+            let connectedListener = () => undefined;
+            const connectedPromise = new Promise((resolve) => {
+                connectedListener = (payload) => {
+                    if (channelName === payload.channelName) {
+                        resolve(true);
+                    }
+                };
+                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
             });
-            const { payload: { data: routingInfo } } = res;
-            // If there isn't a matching channel, the above sendAction call will error out and go to catch, skipping the logic below.
-            if (resolver) {
-                resolver();
-            }
-            this.removeListener('connected', listener);
-            const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-            const channel = new client_1.default(routingInfo, this.wire, strategy);
-            // It is the client's responsibility to handle endpoint disconnection to the provider.
-            // If the endpoint dies, the client will force a disconnection through the core.
-            // The provider does not care about endpoint disconnection.
-            strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
-                try {
-                    await channel.sendDisconnectAction();
+            try {
+                if (retryInfo.count > 0) {
+                    // Wait before retrying
+                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event
+                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);
+                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });
+                    // log only if there was a retry
+                    console.log(`Successfully connected to channelName: ${channelName}`);
+                    return result.payload.data;
                 }
-                catch (error) {
-                    console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
+                // Send retryInfo to the core for debug log inclusion
+                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);
+                // Save messageId from the first connection attempt
+                retryInfo.originalMessageId = sentMessagePromise.messageId;
+                const result = await sentMessagePromise;
+                return result.payload.data;
+            }
+            catch (error) {
+                if (!error.message.includes('internal-nack')) {
+                    // Not an internal nack, break the loop
+                    throw error;
                 }
-                finally {
-                    client_1.default.handleProviderDisconnect(routingInfo);
+                if (shouldWait && retryInfo.count === 0) {
+                    // start waiting on the next iteration, warn the user
+                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);
                 }
-            });
-            return channel;
+            }
+            finally {
+                retryInfo.count += 1;
+                // in case of other errors, remove our listener
+                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+            }
+        } while (shouldWait); // If we're waiting we retry the above loop
+        // Should wait was false, no channel was found.
+        throw new Error(`No channel found for channelName: ${channelName}.`);
+        /* eslint-enable no-await-in-loop, no-constant-condition */
+    }
+    async connect(channelName, options = {}) {
+        // Make sure we don't connect before listeners are set up
+        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
+        await __classPrivateFieldGet(this, _Channel_readyToConnect, "f").getValue();
+        if (!channelName || typeof channelName !== 'string') {
+            throw new Error('Please provide a channelName string to connect to a channel.');
+        }
+        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        let connectionUrl;
+        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
+            connectionUrl = (await this.fin.me.getInfo()).url;
         }
-        catch (e) {
-            const shouldWait = { wait: true, ...opts }.wait;
-            const internalNackMessage = 'internal-nack';
-            if (shouldWait && e.message && e.message.includes(internalNackMessage)) {
-                console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
-                return waitResponse;
+        const connectPayload = {
+            channelName,
+            ...opts,
+            offer,
+            connectionUrl
+        };
+        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
+        const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const channel = new client_1.default(routingInfo, this.wire, strategy);
+        // It is the client's responsibility to handle endpoint disconnection to the provider.
+        // If the endpoint dies, the client will force a disconnection through the core.
+        // The provider does not care about endpoint disconnection.
+        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
+            try {
+                await channel.sendDisconnectAction();
             }
-            if (e.message === internalNackMessage) {
-                throw new Error(`No channel found for channelName: ${channelName}`);
+            catch (error) {
+                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
             }
-            else {
-                throw new Error(e);
+            finally {
+                client_1.default.handleProviderDisconnect(routingInfo);
             }
-        }
+        });
+        return channel;
     }
     async create(channelName, options) {
         if (!channelName) {
@@ -129,4 +166,4 @@ class Channel extends base_1.EmitterBase {
     }
 }
 exports.Channel = Channel;
-_Channel_connectionManager = new WeakMap();
+_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();

package/src/api/interappbus/channel/protocols/classic/strategy.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap;
+var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicInfo = exports.ClassicStrategy = void 0;
 /*
@@ -26,7 +26,11 @@ class ClassicStrategy {
         // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
         // (clients will only have 1: the provider, the provider will have all clients)
         _ClassicStrategy_endpointIdentityMap.set(this, new Map());
+        // Store a set of cancellable promises to be able to reject them when client
+        // connection problems occur
+        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
+            var _a;
             const to = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
@@ -38,20 +42,27 @@ class ClassicStrategy {
                 delete cleanId.endpointId;
             }
             delete cleanId.isLocalEndpointId;
-            const raw = await __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
+            // grab the promise before awaiting it to save in our pending messages map
+            const p = __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
                 .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
                 payload
-            })
-                .catch((reason) => {
-                throw new Error(reason.message);
+            });
+            (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.add(p);
+            const raw = await p.catch((error) => {
+                throw new Error(error.message);
+            }).finally(() => {
+                var _a;
+                // clean up the pending promise
+                (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.delete(p);
             });
             return raw.payload.data.result;
         };
         this.close = async () => {
             this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
+            [...__classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
             __classPrivateFieldSet(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
         __classPrivateFieldSet(this, _ClassicStrategy_wire, wire, "f");
@@ -63,13 +74,20 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
+        const id = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
         __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        pendingSet === null || pendingSet === void 0 ? void 0 : pendingSet.forEach((p) => {
+            const errorMsg = `Channel connection with identity uuid: ${id === null || id === void 0 ? void 0 : id.uuid} / name: ${id === null || id === void 0 ? void 0 : id.name} / endpointId: ${endpointId} no longer connected.`;
+            p.cancel(new Error(errorMsg));
+        });
     }
     isEndpointConnected(endpointId) {
         return __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
         __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
         var _a, _b;
@@ -78,6 +96,6 @@ class ClassicStrategy {
     }
 }
 exports.ClassicStrategy = ClassicStrategy;
-_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap();
+_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();
 // Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
 exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };

package/src/api/interappbus/index.js

@@ -17,7 +17,7 @@ class InterApplicationBus extends base_1.Base {
             subscriberAdded: 'subscriber-added',
             subscriberRemoved: 'subscriber-removed'
         };
-        this.refCounter = new ref_counter_1.default();
+        this.refCounter = new ref_counter_1.RefCounter();
         this.Channel = new index_1.Channel(wire);
         this.emitter = new events_1.EventEmitter();
         wire.registerMessageHandler(this.onmessage.bind(this));

package/src/api/interop/InteropClient.d.ts

@@ -88,7 +88,7 @@ import { Base } from '../base';
  * @summary A SessionContextGroup instance method for adding a handler for context change.
  * @param {ContextHandler} contextHandler The callback to be invoked. Is invoked when (a) the context changes or (b) immediately after getting created if the context is already set.
  * @param {string} [contextType] The context type this handler should listen to. If not specified, a global handler for all context types will get created. Only one global handler is allowed per SessionContextGroup.
- * @return {Promise<void>}
+ * @return {Promise<Subscription>}
  */
 /**
  * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}

package/src/api/interop/InteropClient.js

@@ -103,7 +103,7 @@ const utils_1 = require("./utils");
  * @summary A SessionContextGroup instance method for adding a handler for context change.
  * @param {ContextHandler} contextHandler The callback to be invoked. Is invoked when (a) the context changes or (b) immediately after getting created if the context is already set.
  * @param {string} [contextType] The context type this handler should listen to. If not specified, a global handler for all context types will get created. Only one global handler is allowed per SessionContextGroup.
- * @return {Promise<void>}
+ * @return {Promise<Subscription>}
  */
 /**
  * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}

package/src/api/interop/SessionContextGroupBroker.d.ts

@@ -18,7 +18,7 @@ export default class SessionContextGroupBroker {
     handlerAdded(payload: {
         handlerId: string;
         contextType?: string;
-    }, clientIdentity: OpenFin.ClientIdentity): void;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
     handlerRemoved(payload: {
         handlerId: string;
     }, clientIdentity: OpenFin.ClientIdentity): void;

package/src/api/interop/SessionContextGroupBroker.js

@@ -48,7 +48,7 @@ class SessionContextGroupBroker {
     getClientState(id) {
         return this.clients.get(id.endpointId);
     }
-    handlerAdded(payload, clientIdentity) {
+    async handlerAdded(payload, clientIdentity) {
         const { handlerId, contextType } = payload;
         const clientSubscriptionState = this.getClientState(clientIdentity);
         if (!clientSubscriptionState) {
@@ -59,17 +59,18 @@ class SessionContextGroupBroker {
             clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);
             const currentContext = this.contextGroupMap.get(contextType);
             if (currentContext) {
-                this.provider.dispatch(clientIdentity, handlerId, currentContext);
+                await this.provider.dispatch(clientIdentity, handlerId, currentContext);
             }
         }
         else {
             clientSubscriptionState.globalHandler = handlerId;
-            [...this.contextGroupMap.keys()].forEach((currentContextType) => {
+            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {
                 const currentContext = this.contextGroupMap.get(currentContextType);
                 if (currentContext) {
-                    this.provider.dispatch(clientIdentity, handlerId, currentContext);
+                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);
                 }
             });
+            await Promise.all(globalDispatchPromises);
         }
     }
     handlerRemoved(payload, clientIdentity) {

package/src/api/interop/SessionContextGroupClient.js

@@ -63,7 +63,7 @@ class SessionContextGroupClient extends base_1.Base {
             handlerId = `sessionContextHandler:invoke-${this.id}`;
         }
         client.register(handlerId, (0, utils_1.wrapContextHandler)(contextHandler, handlerId));
-        client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
+        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
         return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
     }
     async createUnsubscribeCb(handlerId) {

package/src/api/interop/fdc3/PrivateChannelProvider.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../OpenFin';
-import { ChannelProvider } from '../../interappbus/channel/provider';
+type ChannelProvider = OpenFin.ChannelProvider;
 type HandlerId = string;
 type ContextType = string;
 interface PrivateChannelClientState {

package/src/api/interop/fdc3/PrivateChannelProvider.js

@@ -84,16 +84,9 @@ class PrivateChannelProvider {
         if (contextType) {
             const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];
             senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);
-            const currContext = this.contextByContextType.get(contextType);
-            if (currContext) {
-                this.provider.dispatch(senderClientIdentity, handlerId, currContext);
-            }
         }
         else {
             senderClientState.globalHandler = handlerId;
-            if (this.lastContext) {
-                this.provider.dispatch(senderClientIdentity, handlerId, this.lastContext);
-            }
         }
         Array.from(this.clients.values()).forEach((currClientState) => {
             if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&
@@ -271,7 +264,7 @@ class PrivateChannelProvider {
         const allClientInfo = await this.provider.getAllClientInfo();
         return Array.from(this.clients.values()).filter((clientState) => {
             const { uuid, name } = clientState.clientIdentity;
-            return allClientInfo.some(clientInfo => {
+            return allClientInfo.some((clientInfo) => {
                 return name === clientInfo.name && uuid === clientInfo.uuid;
             });
         });

package/src/api/interop/fdc3/fdc3-1.2.js

@@ -4,6 +4,7 @@ const base_1 = require("../../base");
 const utils_1 = require("./utils");
 const utils_2 = require("../utils");
 const InteropClient_1 = require("../InteropClient");
+const lodash_1 = require("lodash");
 /**
  * @typedef { object } Listener
  * @summary Listener object returned by addContextListener and addIntentListener
@@ -393,7 +394,39 @@ class Fdc3Module extends base_1.Base {
         return {
             ...currentContextGroupInfo,
             type: 'system',
-            addContextListener: this.addContextListener.bind(this),
+            addContextListener: (contextType, handler) => {
+                let realHandler;
+                let realType;
+                if (typeof contextType === 'function') {
+                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                    realHandler = contextType;
+                }
+                else {
+                    realHandler = handler;
+                    if (typeof contextType === 'string') {
+                        realType = contextType;
+                    }
+                }
+                const listener = (async () => {
+                    let first = true;
+                    const currentContext = await this.fin.me.interop.getCurrentContext(realType);
+                    const wrappedHandler = (context, contextMetadata) => {
+                        if (first) {
+                            first = false;
+                            if ((0, lodash_1.isEqual)(currentContext, context)) {
+                                return;
+                            }
+                        }
+                        // eslint-disable-next-line consistent-return
+                        return realHandler(context, contextMetadata);
+                    };
+                    return this.fin.me.interop.addContextHandler(wrappedHandler, realType);
+                })();
+                return {
+                    ...listener,
+                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+                };
+            },
             broadcast: this.broadcast.bind(this),
             getCurrentContext: async (contextType) => {
                 const context = await this.fin.me.interop.getCurrentContext(contextType);

package/src/api/interop/fdc3/utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
 const utils_1 = require("../utils");
 const PrivateChannelClient_1 = require("./PrivateChannelClient");
+const lodash_1 = require("lodash");
 const getUnsupportedChannelApis = (channelType) => {
     return {
         addContextListener: () => {
@@ -111,14 +112,33 @@ const buildAppChannelObject = (sessionContextGroup) => {
             return context === undefined ? null : context;
         },
         addContextListener: (contextType, handler) => {
-            let listener;
+            let realHandler;
+            let realType;
             if (typeof contextType === 'function') {
                 console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
-                listener = sessionContextGroup.addContextHandler(contextType);
+                realHandler = contextType;
             }
             else {
-                listener = sessionContextGroup.addContextHandler(handler, contextType === null ? undefined : contextType);
+                realHandler = handler;
+                if (typeof contextType === 'string') {
+                    realType = contextType;
+                }
             }
+            const listener = (async () => {
+                let first = true;
+                const currentContext = await sessionContextGroup.getCurrentContext(realType);
+                const wrappedHandler = (context, contextMetadata) => {
+                    if (first) {
+                        first = false;
+                        if ((0, lodash_1.isEqual)(currentContext, context)) {
+                            return;
+                        }
+                    }
+                    // eslint-disable-next-line consistent-return
+                    return realHandler(context, contextMetadata);
+                };
+                return sessionContextGroup.addContextHandler(wrappedHandler, realType);
+            })();
             return {
                 ...listener,
                 unsubscribe: () => listener.then((l) => l.unsubscribe())
@@ -149,7 +169,7 @@ exports.isContext = isContext;
 const isChannel = (channel) => {
     if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
         const { type, id } = channel;
-        return (typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private'));
+        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');
     }
     return false;
 };

package/src/api/me.d.ts

@@ -33,7 +33,7 @@ export declare function getBaseMe<T extends EntityType = EntityType>(entityType:
 export interface WithInterop {
     interop: InteropClient;
 }
-export type Me<MeType extends EntityType> = OpenFin.EntityInfo & (MeType extends 'view' ? EntityTypeHelpers<'view'> & OpenFin.View & WithInterop : MeType extends 'window' ? EntityTypeHelpers<'window'> & OpenFin.Window & WithInterop : MeType extends 'iframe' ? EntityTypeHelpers<'iframe'> & OpenFin.Frame & WithInterop : EntityTypeHelpers<MeType> & WithInterop) & {
+export type Me<MeType extends EntityType> = OpenFin.EntityInfo & (MeType extends 'view' ? EntityTypeHelpers<'view'> & OpenFin.View & WithInterop : MeType extends 'window' ? EntityTypeHelpers<'window'> & OpenFin.Window & WithInterop : MeType extends 'iframe' ? EntityTypeHelpers<'iframe'> & OpenFin.Frame & WithInterop : MeType extends 'external connection' ? EntityTypeHelpers<'external connection'> & OpenFin.ExternalApplication & WithInterop : EntityTypeHelpers<MeType> & WithInterop) & {
     isOpenFin: boolean;
 };
 export declare function getMe<MeType extends EntityType>(wire: Transport<MeType>): Me<MeType>;

package/src/api/me.js

@@ -4,6 +4,7 @@ exports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void
 const view_1 = require("./view");
 const frame_1 = require("./frame");
 const window_1 = require("./window");
+const external_application_1 = require("./external-application");
 exports.environmentUnsupportedMessage = 'You are not running in OpenFin.';
 function getBaseMe(entityType, uuid, name) {
     const entityTypeHelpers = {
@@ -117,7 +118,7 @@ function getMe(wire) {
                 isOpenFin: true
             });
         case 'external connection':
-            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+            return Object.assign(new external_application_1.ExternalApplication(wire, { uuid }), getBaseMe(entityType, uuid, name), {
                 interop: fallbackInterop,
                 isOpenFin: false
             });

package/src/api/platform/Factory.d.ts

@@ -1,8 +1,8 @@
 import type * as OpenFin from '../../OpenFin';
-import { Base } from '../base';
-import { Channel } from '../interappbus/channel/index';
 import { Transport } from '../../transport/transport';
+import { Base } from '../base';
 import { LayoutModule } from './layout/index';
+type Channel = OpenFin.Fin['InterApplicationBus']['Channel'];
 /**
  * @PORTED
  * InitPlatformOptions interface
@@ -51,7 +51,6 @@ import { LayoutModule } from './layout/index';
 export default class PlatformModule extends Base {
     private _channel;
     Layout: LayoutModule;
-    private _initializer;
     constructor(wire: Transport, channel: Channel);
     /**
      * Initializes a Platform. Must be called from the Provider when using a custom provider.
@@ -113,3 +112,4 @@ export default class PlatformModule extends Base {
      */
     startFromManifest(manifestUrl: string, opts?: OpenFin.RvmLaunchOptions): Promise<OpenFin.Platform>;
 }
+export {};

package/src/api/platform/Factory.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-undef, no-underscore-dangle */
 const base_1 = require("../base");
-const index_1 = require("./layout/index");
 const Instance_1 = require("./Instance");
+const index_1 = require("./layout/index");
 /**
  * @PORTED
  * InitPlatformOptions interface
@@ -53,9 +52,6 @@ class PlatformModule extends base_1.Base {
     constructor(wire, channel) {
         super(wire);
         this._channel = channel;
-        this._initializer = (...args) => this.wire.environment
-            .getProviderInitializer()
-            .then((initConstructor) => initConstructor(this.wire.environment)(...args));
         /**
          * @namespace
          * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace
@@ -74,12 +70,7 @@ class PlatformModule extends base_1.Base {
      * @static
      */
     async init(options) {
-        const overrideCallback = options === null || options === void 0 ? void 0 : options.overrideCallback;
-        const interopBroker = await this.fin.Interop.init(this.fin.me.uuid, options === null || options === void 0 ? void 0 : options.interopOverride);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error debugging purposes
-        window.interopBroker = interopBroker;
-        return this._initializer(overrideCallback, interopBroker);
+        return this.wire.environment.initPlatform(this.fin, options);
     }
     /**
      * Asynchronously returns a Platform object that represents an existing platform.

package/src/api/platform/Instance.d.ts

@@ -1,9 +1,9 @@
 import type * as OpenFin from '../../OpenFin';
-import { View } from '../view';
 import { EmitterBase } from '../base';
-import { Channel } from '../interappbus/channel/index';
-import ChannelClient from '../interappbus/channel/client';
-import { LayoutModule } from './layout';
+type View = OpenFin.View;
+type Channel = OpenFin.Fin['InterApplicationBus']['Channel'];
+type ChannelClient = OpenFin.ChannelClient;
+type LayoutModule = OpenFin.Fin['Platform']['Layout'];
 /** Manages the life cycle of windows and views in the application.
  *
  * Enables taking snapshots of itself and applyi
@@ -147,3 +147,4 @@ export declare class Platform extends EmitterBase<OpenFin.PlatformEvent> {
         skipBeforeUnload: boolean;
     }): Promise<void>;
 }
+export {};