@openfin/core 31.74.17 → 31.74.19

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "31.74.17",
+    "version": "31.74.19",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/api/interop/InteropBroker.js

@@ -5,6 +5,7 @@ const base_1 = require("../base");
 const SessionContextGroupBroker_1 = require("./SessionContextGroupBroker");
 const utils_1 = require("./utils");
 const lodash_1 = require("lodash");
+const PrivateChannelProvider_1 = require("./fdc3/PrivateChannelProvider");
 let contextGroups = [
     {
         id: 'green',
@@ -1050,6 +1051,11 @@ class InteropBroker extends base_1.Base {
         channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {
             return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);
         });
+        channel.register('createPrivateChannelProvider', async (payload) => {
+            const { channelId } = payload;
+            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
+            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);
+        });
     }
     /**
      * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.

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

@@ -14,6 +14,7 @@ export declare class PrivateChannelClient {
     onAddContextListener(handler: (contextType?: string) => void): Listener;
     onDisconnect(handler: () => void): Listener;
     onUnsubscribe(handler: (contextType?: string) => void): Listener;
+    cleanUpAllSubs(): Promise<void>;
     disconnect(): Promise<void>;
 }
 export {};

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

@@ -69,14 +69,22 @@ class PrivateChannelClient {
         this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
         return listener;
     }
-    async disconnect() {
-        const listenerUnsubscribers = Array.from(this.listeners.values());
-        const promises = listenerUnsubscribers.map(async (listenerUnsubscriber) => {
-            await listenerUnsubscriber.unsubscribe();
+    async cleanUpAllSubs() {
+        const listenerUnsubscribers = Array.from(this.listeners.keys());
+        listenerUnsubscribers.forEach((handlerId) => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
         });
-        await Promise.all(promises);
-        await this.client.dispatch('clientDisconnecting');
-        await this.client.disconnect();
+    }
+    async disconnect() {
+        try {
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
     }
 }
 exports.PrivateChannelClient = PrivateChannelClient;

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

@@ -1,6 +1,15 @@
 import type * as OpenFin from '../../../OpenFin';
 import { ChannelProvider } from '../../interappbus/channel/provider';
 type HandlerId = string;
+type ContextType = string;
+interface PrivateChannelClientState {
+    clientIdentity: OpenFin.ClientIdentity;
+    handlerIdsByContextTypes: Map<ContextType, HandlerId[]>;
+    globalHandler: HandlerId | undefined;
+    onAddContextListenerHandlerId: HandlerId | undefined;
+    onUnsubscribeHandlerId: HandlerId | undefined;
+    onDisconnectHandlerId: HandlerId | undefined;
+}
 export declare class PrivateChannelProvider {
     id: string;
     private provider;
@@ -35,7 +44,12 @@ export declare class PrivateChannelProvider {
     onUnsubscribeHandlerAdded(payload: {
         handlerId: HandlerId;
     }, id: OpenFin.ClientIdentity): void;
-    clientDisconnecting(payload: {}, disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    removeClient(disconnectingClientIdentity: OpenFin.ClientIdentity): void;
+    fireOnDisconnectForOtherClients(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    unsubscribeAll(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    handleClientDisconnecting(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
     registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
+    getConnectedClients(): Promise<PrivateChannelClientState[]>;
+    static init(channelProvider: OpenFin.ChannelProvider, id: string): PrivateChannelProvider;
 }
 export {};

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

@@ -11,7 +11,15 @@ class PrivateChannelProvider {
         this.contextByContextType = new Map();
         this.lastContext = undefined;
         this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
-        this.provider.onDisconnection((clientIdentity) => this.clients.delete(clientIdentity.endpointId));
+        this.provider.onDisconnection(async (clientIdentity) => {
+            const { endpointId } = clientIdentity;
+            if (this.clients.has(endpointId)) {
+                await this.handleClientDisconnecting(clientIdentity);
+            }
+            if ((await this.provider.getAllClientInfo()).length === 0) {
+                this.provider.destroy();
+            }
+        });
     }
     getClientState(id) {
         return this.clients.get(id.endpointId);
@@ -25,7 +33,9 @@ class PrivateChannelProvider {
         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));
+        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {
+            this.handleClientDisconnecting(clientIdentity);
+        });
     }
     broadcast(payload, broadcasterClientIdentity) {
         const { context } = payload;
@@ -110,17 +120,18 @@ class PrivateChannelProvider {
                     }
                 }
             }
-            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));
+            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+            // so we need to ensure we don't dispatch to any disconnected client
+            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+            const clientsToDispatchTo = await this.getConnectedClients();
+            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;
+                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {
+                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);
                 }
-            }
+            });
             try {
-                await Promise.all(dispatchesToSend);
+                await Promise.all(dispatchPromises);
             }
             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}`);
@@ -181,32 +192,68 @@ class PrivateChannelProvider {
         }
         clientState.onUnsubscribeHandlerId = handlerId;
     }
-    async clientDisconnecting(payload, disconnectingClientIdentity) {
+    removeClient(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 = [];
+    }
+    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {
         // 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));
+        const { endpointId } = disconnectingClientIdentity;
+        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+        // so we need to ensure we don't dispatch to any disconnected client
+        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+        const clientsToDispatchTo = await this.getConnectedClients();
+        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;
+            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {
+                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);
             }
-        }
+        });
         try {
-            await Promise.all(dispatchesToSend);
+            await Promise.all(dispatchPromises);
         }
         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);
         }
     }
+    async unsubscribeAll(clientIdentity) {
+        const { endpointId } = clientIdentity;
+        const state = this.clients.get(endpointId);
+        if (state) {
+            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();
+            const globalHandlerId = state.globalHandler;
+            if (contextTypeHandlerIds.length > 0) {
+                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {
+                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);
+                });
+                try {
+                    await Promise.all(unsubPromises);
+                }
+                catch (error) {
+                    console.error(error.message);
+                }
+            }
+            if (globalHandlerId) {
+                try {
+                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);
+                }
+                catch (error) {
+                    console.error(error.message);
+                }
+            }
+        }
+    }
+    async handleClientDisconnecting(disconnectingClientIdentity) {
+        await this.unsubscribeAll(disconnectingClientIdentity);
+        this.removeClient(disconnectingClientIdentity);
+        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);
+    }
     registerNewClient(clientIdentity) {
         if (!this.clients.has(clientIdentity.endpointId)) {
             const clientSubscriptionState = {
@@ -220,5 +267,17 @@ class PrivateChannelProvider {
             this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
         }
     }
+    async getConnectedClients() {
+        const allClientInfo = await this.provider.getAllClientInfo();
+        return Array.from(this.clients.values()).filter((clientState) => {
+            const { uuid, name } = clientState.clientIdentity;
+            return allClientInfo.some(clientInfo => {
+                return name === clientInfo.name && uuid === clientInfo.uuid;
+            });
+        });
+    }
+    static init(channelProvider, id) {
+        return new PrivateChannelProvider(channelProvider, id);
+    }
 }
 exports.PrivateChannelProvider = PrivateChannelProvider;

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

@@ -6,7 +6,6 @@ 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.
@@ -389,8 +388,7 @@ class Fdc3Module2 extends base_1.Base {
      */
     async createPrivateChannel() {
         const channelId = (0, utils_1.generateId)();
-        const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
-        const newPrivateChannelProvider = new PrivateChannelProvider_1.PrivateChannelProvider(channelProvider, channelId);
+        await InteropClient_1.InteropClient.ferryFdc3Call(this.fin.me.interop, 'createPrivateChannelProvider', { channelId });
         const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
         const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
         return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);

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

@@ -457,6 +457,10 @@ export declare class View extends WebContents<ViewEvent> {
      * **NOTE**: Internal use only.
      * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.
      *
+     * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.
+     *
+     * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.
+     *
      * @param {HTMLElement} element - HTML element to attach the view to.
      * @return {Function} - Cleanup function that will disconnect the element resize observer.
      * @internal

package/src/api/view/Instance.js

@@ -461,6 +461,10 @@ class View extends main_1.WebContents {
          * **NOTE**: Internal use only.
          * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.
          *
+         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.
+         *
+         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.
+         *
          * @param {HTMLElement} element - HTML element to attach the view to.
          * @return {Function} - Cleanup function that will disconnect the element resize observer.
          * @internal