@openfin/core 29.72.18 → 30.73.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "29.72.18",
+    "version": "30.73.2",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

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

@@ -0,0 +1,17 @@
+declare type HandlerId = string;
+export declare class PrivateChannelClient {
+    id: string;
+    client: OpenFin.ChannelClient;
+    listeners: Map<HandlerId, FDC3v2.Listener>;
+    constructor(client: OpenFin.ChannelClient, id: string);
+    broadcast(context: OpenFin.Context): Promise<void>;
+    getCurrentContext(contextType?: string): Promise<OpenFin.Context | null>;
+    addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): Promise<FDC3v2.Listener>;
+    private createNonStandardUnsubscribeCb;
+    private createContextUnsubscribeCb;
+    onAddContextListener(handler: (contextType?: string) => void): FDC3v2.Listener;
+    onDisconnect(handler: () => void): FDC3v2.Listener;
+    onUnsubscribe(handler: (contextType?: string) => void): FDC3v2.Listener;
+    disconnect(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateChannelClient = void 0;
+const utils_1 = require("../utils");
+class PrivateChannelClient {
+    constructor(client, id) {
+        this.id = id;
+        this.client = client;
+        this.listeners = new Map();
+    }
+    async broadcast(context) {
+        this.client.dispatch('broadcast', { context });
+    }
+    async getCurrentContext(contextType) {
+        return this.client.dispatch('getCurrentContext', { contextType });
+    }
+    async addContextListener(contextType, handler) {
+        if (typeof handler !== 'function') {
+            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        let handlerId;
+        if (contextType) {
+            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils_1.generateId()}`;
+        }
+        else {
+            handlerId = `contextHandler:invoke-${this.id}-${utils_1.generateId()}`;
+        }
+        this.client.register(handlerId, utils_1.wrapContextHandler(handler, handlerId));
+        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
+        return listener;
+    }
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
+        };
+    }
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
+    }
+    onAddContextListener(handler) {
+        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onDisconnect(handler) {
+        const handlerId = `onDisconnect:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onUnsubscribe(handler) {
+        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
+        return listener;
+    }
+    async disconnect() {
+        const promises = [];
+        const listenerUnsubscribers = Array.from(this.listeners.values());
+        for (let i = 0; i < listenerUnsubscribers.length; i++) {
+            const listener = listenerUnsubscribers[i];
+            promises.push(listener.unsubscribe());
+        }
+        await Promise.all(promises);
+        await this.client.dispatch('clientDisconnecting');
+        await this.client.disconnect();
+    }
+}
+exports.PrivateChannelClient = PrivateChannelClient;

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

@@ -0,0 +1,40 @@
+import { ChannelProvider } from '../../interappbus/channel/provider';
+declare type HandlerId = string;
+export declare class PrivateChannelProvider {
+    id: string;
+    private provider;
+    private clients;
+    private contextByContextType;
+    private lastContext;
+    constructor(provider: ChannelProvider, id: string);
+    private getClientState;
+    registerListeners(): void;
+    broadcast(payload: {
+        context: OpenFin.Context;
+    }, broadcasterClientIdentity: OpenFin.ClientIdentity): void;
+    getCurrentContext(payload: {
+        contextType?: string;
+    }, senderClientIdentity: OpenFin.ClientIdentity): OpenFin.Context | null;
+    contextHandlerAdded(payload: {
+        handlerId: HandlerId;
+        contextType?: string;
+    }, senderClientIdentity: OpenFin.ClientIdentity): void;
+    contextHandlerRemoved(payload: {
+        handlerId: HandlerId;
+    }, removingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    nonStandardHandlerRemoved(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    onAddContextHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, senderClientIdentity: OpenFin.ClientIdentity): void;
+    onDisconnectHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    onUnsubscribeHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    clientDisconnecting(payload: {}, disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
+}
+export {};

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

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateChannelProvider = void 0;
+const InteropBroker_1 = require("../InteropBroker");
+class PrivateChannelProvider {
+    constructor(provider, id) {
+        this.provider = provider;
+        this.id = id;
+        this.clients = new Map();
+        this.registerListeners();
+        this.contextByContextType = new Map();
+        this.lastContext = undefined;
+        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
+        this.provider.onDisconnection((clientIdentity) => this.clients.delete(clientIdentity.endpointId));
+    }
+    getClientState(id) {
+        return this.clients.get(id.endpointId);
+    }
+    registerListeners() {
+        this.provider.register('broadcast', this.broadcast.bind(this));
+        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));
+        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));
+        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));
+        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));
+        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));
+        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));
+        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));
+        this.provider.register('clientDisconnecting', this.clientDisconnecting.bind(this));
+    }
+    broadcast(payload, broadcasterClientIdentity) {
+        const { context } = payload;
+        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);
+        if (!broadcasterClientState) {
+            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);
+        }
+        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);
+        if (contextIntegrityCheckResult.isValid === false) {
+            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+        }
+        this.contextByContextType.set(context.type, context);
+        this.lastContext = context;
+        Array.from(this.clients.values()).forEach((currClientState) => {
+            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);
+            if (handlerIdsForContextType) {
+                handlerIdsForContextType.forEach((handlerId) => {
+                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);
+                });
+            }
+            if (currClientState.globalHandler) {
+                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);
+            }
+        });
+    }
+    getCurrentContext(payload, senderClientIdentity) {
+        const { contextType } = payload;
+        const clientState = this.getClientState(senderClientIdentity);
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);
+        }
+        if (contextType !== undefined) {
+            const currentContext = this.contextByContextType.get(contextType);
+            if (currentContext)
+                return currentContext;
+            return null;
+        }
+        return this.lastContext ? this.lastContext : null;
+    }
+    contextHandlerAdded(payload, senderClientIdentity) {
+        const { handlerId, contextType } = payload;
+        const senderClientState = this.getClientState(senderClientIdentity);
+        if (!senderClientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);
+        }
+        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 &&
+                currClientState.onAddContextListenerHandlerId) {
+                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);
+            }
+        });
+    }
+    async contextHandlerRemoved(payload, removingClientIdentity) {
+        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.
+        const { handlerId } = payload;
+        const removingClientState = this.getClientState(removingClientIdentity);
+        if (removingClientState) {
+            let contextType;
+            if (removingClientState.globalHandler === handlerId) {
+                removingClientState.globalHandler = undefined;
+            }
+            else {
+                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {
+                    const index = handlersIds.indexOf(handlerId);
+                    if (index > -1) {
+                        handlersIds.splice(index, 1);
+                        contextType = currContextType;
+                    }
+                }
+            }
+            const dispatchesToSend = [];
+            const otherClientStates = Array.from(this.clients.values());
+            for (let i = 0; i < otherClientStates.length; i++) {
+                const otherClientState = otherClientStates[i];
+                if (otherClientState.clientIdentity.endpointId !== removingClientIdentity.endpointId &&
+                    otherClientState.onUnsubscribeHandlerId) {
+                    dispatchesToSend.push(this.provider.dispatch(otherClientState.clientIdentity, otherClientState.onUnsubscribeHandlerId, contextType));
+                }
+            }
+            try {
+                await Promise.all(dispatchesToSend);
+            }
+            catch (error) {
+                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);
+                throw new Error(error);
+            }
+        }
+        else {
+            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);
+        }
+    }
+    nonStandardHandlerRemoved(payload, id) {
+        const { handlerId } = payload;
+        const clientState = this.getClientState(id);
+        if (clientState) {
+            if (clientState.onDisconnectHandlerId === handlerId) {
+                clientState.onDisconnectHandlerId = undefined;
+            }
+            else if (clientState.onAddContextListenerHandlerId === handlerId) {
+                clientState.onAddContextListenerHandlerId = undefined;
+            }
+            else if (clientState.onUnsubscribeHandlerId === handlerId) {
+                clientState.onUnsubscribeHandlerId = undefined;
+            }
+        }
+        else {
+            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);
+        }
+    }
+    onAddContextHandlerAdded(payload, senderClientIdentity) {
+        const clientState = this.getClientState(senderClientIdentity);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);
+        }
+        clientState.onAddContextListenerHandlerId = handlerId;
+        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client
+        Array.from(this.clients.values()).forEach((otherClientState) => {
+            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {
+                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {
+                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);
+                });
+            }
+        });
+    }
+    onDisconnectHandlerAdded(payload, id) {
+        const clientState = this.getClientState(id);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);
+        }
+        clientState.onDisconnectHandlerId = handlerId;
+    }
+    onUnsubscribeHandlerAdded(payload, id) {
+        const clientState = this.getClientState(id);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);
+        }
+        clientState.onUnsubscribeHandlerId = handlerId;
+    }
+    async clientDisconnecting(payload, disconnectingClientIdentity) {
+        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);
+        if (!disconnectingClientState) {
+            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);
+        }
+        disconnectingClientState.handlerIdsByContextTypes.clear();
+        this.clients.delete(disconnectingClientIdentity.endpointId);
+        const dispatchesToSend = [];
+        // TODO: call onDisconnect Handler of the other client only.
+        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.
+        const otherClientStates = Array.from(this.clients.values());
+        for (let i = 0; i < otherClientStates.length; i++) {
+            const otherClientState = otherClientStates[i];
+            if (otherClientState.clientIdentity.endpointId !== disconnectingClientIdentity.endpointId &&
+                otherClientState.onDisconnectHandlerId) {
+                dispatchesToSend.push(this.provider.dispatch(otherClientState.clientIdentity, otherClientState.onDisconnectHandlerId));
+            }
+        }
+        try {
+            await Promise.all(dispatchesToSend);
+        }
+        catch (error) {
+            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);
+            throw new Error(error);
+        }
+    }
+    registerNewClient(clientIdentity) {
+        if (!this.clients.has(clientIdentity.endpointId)) {
+            const clientSubscriptionState = {
+                clientIdentity,
+                handlerIdsByContextTypes: new Map(),
+                globalHandler: undefined,
+                onAddContextListenerHandlerId: undefined,
+                onUnsubscribeHandlerId: undefined,
+                onDisconnectHandlerId: undefined
+            };
+            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
+        }
+    }
+}
+exports.PrivateChannelProvider = PrivateChannelProvider;

package/src/api/interop/fdc3/fdc3-2.0.d.ts

@@ -102,6 +102,20 @@ import Transport from '../../../transport/transport';
  * @property { string } [version] The version number of the Intents schema being used.
  * @property { Function } getResult {@link getResult Function} that returns a promise that will resolve to either `Context` data returned by the application that resolves the raised intent or a `Channel` established and returned by the app resolving the intent.
  */
+/**
+ * @typedef { object } PrivateChannel
+ * @summary Object representing a private context channel, which is intended to support secure communication between applications, and extends the Channel interface with event handlers which provide information on the connection state of both parties, ensuring that desktop agents do not need to queue or retain messages that are broadcast before a context listener is added and that applications are able to stop broadcasting messages when the other party has disconnected.
+ * @property { string } id Private Channel Id
+ * @property { string } type Channel Type
+ * @property { DisplayMetadata } [displayMetadata]
+ * @property { function } broadcast
+ * @property { function } getCurrentContext
+ * @property { function } addContextListener
+ * @property { function } onAddContextListener
+ * @property { function } onUnsubscribe
+ * @property { function } onDisconnect
+ * @property { function } disconnect
+ */
 /**
  * @class
  * @alias fdc3v2
@@ -229,7 +243,14 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @tutorial fdc3.getOrCreateChannel
      */
     getOrCreateChannel(channelId: string): Promise<FDC3.Channel>;
-    createPrivateChannel(): Promise<FDC3v2.PrivateChannel | void>;
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     * @returns { Promise<PrivateChannel> }
+     * @tutorial fdc3v2.createPrivateChannel
+     */
+    createPrivateChannel(): Promise<FDC3v2.PrivateChannel>;
+    connectPrivateChannel(channelId: string): Promise<FDC3v2.PrivateChannel>;
+    private buildPrivateChannelObject;
     /**
      * Retrieves a list of the User Channels available for the app to join.
      * @returns { Promise<Channel[]>}

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

@@ -5,6 +5,8 @@ const utils_1 = require("../utils");
 const InteropClient_1 = require("../InteropClient");
 const utils_2 = require("./utils");
 const fdc3_1_2_1 = require("./fdc3-1.2");
+const PrivateChannelClient_1 = require("./PrivateChannelClient");
+const PrivateChannelProvider_1 = require("./PrivateChannelProvider");
 /**
  * @typedef { object } AppIdentifier
  * @summary Identifies an application, or instance of an application, and is used to target FDC3 API calls at specific applications.
@@ -107,6 +109,20 @@ const fdc3_1_2_1 = require("./fdc3-1.2");
  * @property { string } [version] The version number of the Intents schema being used.
  * @property { Function } getResult {@link getResult Function} that returns a promise that will resolve to either `Context` data returned by the application that resolves the raised intent or a `Channel` established and returned by the app resolving the intent.
  */
+/**
+ * @typedef { object } PrivateChannel
+ * @summary Object representing a private context channel, which is intended to support secure communication between applications, and extends the Channel interface with event handlers which provide information on the connection state of both parties, ensuring that desktop agents do not need to queue or retain messages that are broadcast before a context listener is added and that applications are able to stop broadcasting messages when the other party has disconnected.
+ * @property { string } id Private Channel Id
+ * @property { string } type Channel Type
+ * @property { DisplayMetadata } [displayMetadata]
+ * @property { function } broadcast
+ * @property { function } getCurrentContext
+ * @property { function } addContextListener
+ * @property { function } onAddContextListener
+ * @property { function } onUnsubscribe
+ * @property { function } onDisconnect
+ * @property { function } disconnect
+ */
 /**
  * @class
  * @alias fdc3v2
@@ -366,9 +382,80 @@ class Fdc3Module2 extends base_1.Base {
     async getOrCreateChannel(channelId) {
         return this.fdc3Module.getOrCreateChannel(channelId);
     }
-    // eslint-disable-next-line class-methods-use-this
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     * @returns { Promise<PrivateChannel> }
+     * @tutorial fdc3v2.createPrivateChannel
+     */
     async createPrivateChannel() {
-        // private channels will be implemented in another PR
+        const channelId = utils_1.generateId();
+        const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
+        const newPrivateChannelProvider = new PrivateChannelProvider_1.PrivateChannelProvider(channelProvider, channelId);
+        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
+        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+        return this.buildPrivateChannelObject(newPrivateChannelClient);
+    }
+    // TODO: need to remove this method and not expose it. Added temporarily for the purposes of testing.
+    // eslint-disable-next-line class-methods-use-this
+    async connectPrivateChannel(channelId) {
+        try {
+            const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+            const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+            return this.buildPrivateChannelObject(privateChannelClient);
+        }
+        catch (error) {
+            throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    buildPrivateChannelObject(privateChannelClient) {
+        let clientDisconnected = false;
+        const checkIfClientDisconnected = () => {
+            if (clientDisconnected) {
+                throw new Error('Private Channel Client has been disconnected from the Private Channel');
+            }
+        };
+        return {
+            id: privateChannelClient.id,
+            type: 'private',
+            broadcast: async (context) => {
+                checkIfClientDisconnected();
+                return privateChannelClient.broadcast(context);
+            },
+            getCurrentContext: async (contextType) => {
+                checkIfClientDisconnected();
+                return privateChannelClient.getCurrentContext(contextType);
+            },
+            addContextListener: async (contextType, handler) => {
+                checkIfClientDisconnected();
+                let handlerInUse = handler;
+                let contextTypeInUse = contextType;
+                if (typeof contextType === 'function') {
+                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                    handlerInUse = contextType;
+                    contextTypeInUse = null;
+                }
+                const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
+                return listener;
+            },
+            onAddContextListener: (handler) => {
+                checkIfClientDisconnected();
+                return privateChannelClient.onAddContextListener(handler);
+            },
+            disconnect: async () => {
+                checkIfClientDisconnected();
+                clientDisconnected = true;
+                return privateChannelClient.disconnect();
+            },
+            onDisconnect: (handler) => {
+                checkIfClientDisconnected();
+                return privateChannelClient.onDisconnect(handler);
+            },
+            onUnsubscribe: (handler) => {
+                checkIfClientDisconnected();
+                return privateChannelClient.onUnsubscribe(handler);
+            }
+        };
     }
     /**
      * Retrieves a list of the User Channels available for the app to join.

package/src/api/platform/layout/controllers/tab-drag-controller.d.ts

@@ -9,17 +9,17 @@ export declare class TabDragController {
     constructor(viewOverlay: ViewOverlay);
     private dropZonePreview?;
     /**
-     * When a tab is dragged from a stack greater than one, it's view will need to be hidden and the
-     * view next in the stack shown.
      *
-     * Conversely, when a view is the last view in a window, it will need to remain visible.
+     * When a tab is dragged out of a stack, it will need to be hidden from the stack.
      *
-     * This function implements this logic accordingly
-     * @param movingView The view which is currently being dragged
-     * @param currentView The current active view of the tabstack
-     * @param isOnlyViewInWindow Indicates whether the moving view is the only in the platform window.
+     * Additionally, if there is a new view to show in the stack, it will be shown at the position specified by
+     * containerBounds
+     *
+     * @param draggingView The view which is currently being dragged
+     * @param containerBounds The bounds of the container of the view to be shown in the stack
+     * @param nextView The view which has become active after dragging the draggingView out.
      */
-    handleTabStackActiveView: (movingView: View, currentView: View, isOnlyViewInWindow: boolean) => Promise<void>;
+    handleTabStackActiveView: (draggingView: View, containerBounds?: OpenFin.Bounds, nextView?: View) => Promise<void>;
     /**
      * Extracts the border and backgroundColor css values from the drop zone preview,
      * and sets the viewOverlay to match them.
@@ -38,6 +38,8 @@ export declare class TabDragController {
      * Disables the click through setting on every view in the platform.
      */
     endDrag: () => Promise<void>;
+    private disposeObserve?;
+    disposeOverlayObserver: () => void;
     /**
      * Observes a golden-layout drop zone preview in order to render a BrowserView
      * overlay whenever a tab is dragged over a droppable region.

package/src/api/platform/layout/controllers/tab-drag-controller.js

@@ -11,29 +11,28 @@ class TabDragController {
     constructor(viewOverlay) {
         this.viewOverlay = viewOverlay;
         /**
-         * When a tab is dragged from a stack greater than one, it's view will need to be hidden and the
-         * view next in the stack shown.
          *
-         * Conversely, when a view is the last view in a window, it will need to remain visible.
+         * When a tab is dragged out of a stack, it will need to be hidden from the stack.
          *
-         * This function implements this logic accordingly
-         * @param movingView The view which is currently being dragged
-         * @param currentView The current active view of the tabstack
-         * @param isOnlyViewInWindow Indicates whether the moving view is the only in the platform window.
+         * Additionally, if there is a new view to show in the stack, it will be shown at the position specified by
+         * containerBounds
+         *
+         * @param draggingView The view which is currently being dragged
+         * @param containerBounds The bounds of the container of the view to be shown in the stack
+         * @param nextView The view which has become active after dragging the draggingView out.
          */
-        this.handleTabStackActiveView = async (movingView, currentView, isOnlyViewInWindow) => {
+        this.handleTabStackActiveView = async (draggingView, containerBounds, nextView) => {
             if (this.dropZonePreview) {
-                const hideMovingViewIfPossible = async () => {
-                    if (!isOnlyViewInWindow) {
-                        await movingView.hide();
-                    }
-                };
-                const showCurrentView = async () => {
-                    if (currentView.identity.name !== movingView.identity.name) {
-                        await currentView.show();
-                    }
-                };
-                await Promise.all([hideMovingViewIfPossible(), showCurrentView()]);
+                if (nextView && containerBounds) {
+                    // Due to https://github.com/electron/electron/issues/20064, 
+                    // setBounds does not work in certain scenarios.
+                    // Therefore we call it twice before and after showing to ensure as much 
+                    // visual fidelity as possible (although flicker can still occur).
+                    await (nextView === null || nextView === void 0 ? void 0 : nextView.setBounds(containerBounds));
+                    await (nextView === null || nextView === void 0 ? void 0 : nextView.show());
+                    await (nextView === null || nextView === void 0 ? void 0 : nextView.setBounds(containerBounds));
+                }
+                await draggingView.hide();
             }
         };
         /**
@@ -63,6 +62,12 @@ class TabDragController {
         this.endDrag = async () => {
             await this.viewOverlay.setIgnoreViewMouseEvents(false);
         };
+        this.disposeOverlayObserver = () => {
+            if (this.disposeObserve) {
+                this.disposeObserve();
+            }
+            this.dropZonePreview = undefined;
+        };
         /**
          * Observes a golden-layout drop zone preview in order to render a BrowserView
          * overlay whenever a tab is dragged over a droppable region.
@@ -74,7 +79,7 @@ class TabDragController {
                 this.dropZonePreview = dropZonePreview;
                 let lastBounds;
                 dropZonePreview.style.visibility = 'hidden';
-                dropZonePreview.addEventListener('drop-area-highlighted', async (e) => {
+                const onDropAreaHighlighted = async (e) => {
                     try {
                         const { bounds } = e.detail;
                         if (!lastBounds || !bounds_observer_1.isDomRectEqual(lastBounds, bounds)) {
@@ -85,8 +90,8 @@ class TabDragController {
                     catch (error) {
                         console.warn('Unexpected error encountered rendering tab drag preview.', error);
                     }
-                });
-                dropZonePreview.addEventListener('drop-area-hidden', async () => {
+                };
+                const onDropAreaHidden = async () => {
                     try {
                         lastBounds = undefined;
                         await this.viewOverlay.detachOverlay();
@@ -94,7 +99,16 @@ class TabDragController {
                     catch (error) {
                         console.warn('Unexpected error encountered hiding tab drag preview.', error);
                     }
-                });
+                };
+                dropZonePreview.addEventListener('drop-area-highlighted', onDropAreaHighlighted);
+                dropZonePreview.addEventListener('drop-area-hidden', onDropAreaHidden);
+                this.disposeObserve = () => {
+                    dropZonePreview.removeEventListener('drop-area-highlighted', onDropAreaHighlighted);
+                    dropZonePreview.removeEventListener('drop-area-hidden', onDropAreaHidden);
+                };
+            }
+            else {
+                console.warn('Tried to observe a drop zone overlay without disposing the previous.');
             }
         };
     }