@openfin/core 29.73.13 → 29.73.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "29.73.13",
+    "version": "29.73.14",
     "license": "Apache-2.0",
     "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',
@@ -1043,6 +1044,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

@@ -13,6 +13,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,5 +1,14 @@
 import { ChannelProvider } from '../../interappbus/channel/provider';
 declare type HandlerId = string;
+declare 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;
@@ -34,7 +43,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-1.2.js

@@ -169,11 +169,15 @@ class Fdc3Module extends base_1.Base {
         }
         catch (error) {
             if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
-                throw new Error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
             }
             else {
-                throw new Error(error.message);
+                console.error(error.message);
             }
+            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+                throw new Error(utils_1.ChannelError.NoChannelFound);
+            }
+            throw new Error(utils_1.ChannelError.AccessDenied);
         }
     }
     /**
@@ -317,8 +321,19 @@ class Fdc3Module extends base_1.Base {
         this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
-        return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        const systemChannels = await this.getSystemChannels();
+        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+        if (userChannel) {
+            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+        }
+        try {
+            const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
+            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        }
+        catch (error) {
+            console.error(error.message);
+            throw new Error(utils_1.ChannelError.CreationFailed);
+        }
     }
     /**
      * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.

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.
@@ -349,27 +348,27 @@ class Fdc3Module2 extends base_1.Base {
         // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
         // so we wrap it here and only pass those paramaters.
         const contextHandler = async (raisedIntent) => {
+            let intentResult;
+            let intentResultToSend;
             const { context, metadata: intentMetadata } = raisedIntent;
             const { contextMetadata, metadata, ...rest } = context;
-            let intentResult;
+            const intentResolutionResultId = (intentMetadata === null || intentMetadata === void 0 ? void 0 : intentMetadata.intentResolutionResultId) || (metadata === null || metadata === void 0 ? void 0 : metadata.intentResolutionResultId);
             try {
                 const newContext = metadata ? { metadata, ...rest } : { ...rest };
                 intentResult = await handler(newContext, contextMetadata);
+                intentResultToSend = intentResult;
             }
             catch (error) {
                 intentResult = error;
+                intentResultToSend = { error: true };
             }
-            const intentResolutionResultId = (intentMetadata === null || intentMetadata === void 0 ? void 0 : intentMetadata.intentResolutionResultId) || (metadata === null || metadata === void 0 ? void 0 : metadata.intentResolutionResultId);
             if (intentResolutionResultId) {
-                // Send whatever the result is.
-                fin.InterApplicationBus.publish(intentResolutionResultId, intentResult);
+                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend);
             }
             if (intentResult instanceof Error) {
                 throw new Error(intentResult.message);
             }
-            else {
-                return intentResult;
-            }
+            return intentResult;
         };
         return this.fin.me.interop.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
     }
@@ -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/interop/fdc3/utils.d.ts

@@ -20,8 +20,25 @@ export declare enum ResultError {
      */
     IntentHandlerRejected = "IntentHandlerRejected"
 }
+export declare enum ChannelError {
+    /** Returned if the specified channel is not found when attempting to join a
+     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+     */
+    NoChannelFound = "NoChannelFound",
+    /** SHOULD be returned when a request to join a user channel or to a retrieve
+     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+     *  of the DesktopAgent (`fdc3`) object is denied.
+     */
+    AccessDenied = "AccessDenied",
+    /** SHOULD be returned when a channel cannot be created or retrieved via the
+     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+     */
+    CreationFailed = "CreationFailed"
+}
 export declare const buildPrivateChannelObject: (privateChannelClient: PrivateChannelClient) => PrivateChannel;
 export declare const buildAppChannelObject: (sessionContextGroup: OpenFin.SessionContextGroup) => Channel;
 export declare const connectPrivateChannel: (channelId: string) => Promise<PrivateChannel>;
+export declare const isContext: (context: unknown) => context is Context;
+export declare const isChannel: (channel: unknown) => channel is Channel;
 export declare const getIntentResolution: (interopModule: OpenFin.InteropClient, context: Context, app?: AppIdentifier | TargetApp, intent?: string) => Promise<IntentResolution>;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntentResolution = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
+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 getUnsupportedChannelApis = (channelType) => {
@@ -35,6 +35,22 @@ var ResultError;
      */
     ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
 })(ResultError = exports.ResultError || (exports.ResultError = {}));
+var ChannelError;
+(function (ChannelError) {
+    /** Returned if the specified channel is not found when attempting to join a
+     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+     */
+    ChannelError["NoChannelFound"] = "NoChannelFound";
+    /** SHOULD be returned when a request to join a user channel or to a retrieve
+     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+     *  of the DesktopAgent (`fdc3`) object is denied.
+     */
+    ChannelError["AccessDenied"] = "AccessDenied";
+    /** SHOULD be returned when a channel cannot be created or retrieved via the
+     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+     */
+    ChannelError["CreationFailed"] = "CreationFailed";
+})(ChannelError = exports.ChannelError || (exports.ChannelError = {}));
 const buildPrivateChannelObject = (privateChannelClient) => {
     let clientDisconnected = false;
     const checkIfClientDisconnected = () => {
@@ -122,6 +138,22 @@ const connectPrivateChannel = async (channelId) => {
     }
 };
 exports.connectPrivateChannel = connectPrivateChannel;
+const isContext = (context) => {
+    if (context && typeof context === 'object' && 'type' in context) {
+        const { type } = context;
+        return typeof type === 'string';
+    }
+    return false;
+};
+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 false;
+};
+exports.isChannel = isChannel;
 const getIntentResolution = async (interopModule, context, app, intent) => {
     // Generate an ID to make a session context group with. We will pass that ID to the Broker.
     // The broker will then setContext on that session context group later with our Intent Result,
@@ -138,31 +170,33 @@ const getIntentResolution = async (interopModule, context, app, intent) => {
     // Set up the getResult call.
     const getResult = async () => {
         let intentResult = await getResultPromise;
-        if (!intentResult) {
+        if (!intentResult || typeof intentResult !== 'object') {
             throw new Error(ResultError.NoResultReturned);
         }
-        if (intentResult instanceof Error) {
+        const { error } = intentResult;
+        if (error) {
             throw new Error(ResultError.IntentHandlerRejected);
         }
-        if (typeof intentResult === 'object') {
+        if ((0, exports.isChannel)(intentResult)) {
             const { id, type } = intentResult;
-            if (type && id && typeof id === 'string') {
-                switch (type) {
-                    case 'private': {
-                        intentResult = await (0, exports.connectPrivateChannel)(id);
-                        break;
-                    }
-                    case 'app': {
-                        const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
-                        intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
-                        break;
-                    }
-                    default: {
-                        break;
-                    }
+            switch (type) {
+                case 'private': {
+                    intentResult = await (0, exports.connectPrivateChannel)(id);
+                    break;
+                }
+                case 'app': {
+                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+                    break;
+                }
+                default: {
+                    break;
                 }
             }
         }
+        else if (!(0, exports.isContext)(intentResult)) {
+            throw new Error(ResultError.NoResultReturned);
+        }
         return intentResult;
     };
     // Finally fire the intent.

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

@@ -455,6 +455,10 @@ export declare class View extends WebContents<ViewEvents> {
      * **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

@@ -460,6 +460,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