@microsoft/teams-js 2.23.0 → 2.24.0-beta.0

package/dist/MicrosoftTeams.js

@@ -3395,7 +3395,7 @@ const _minRuntimeConfigToUninitialize = {
  * @hidden
  *  Package version.
  */
-const version = "2.23.0";
+const version = "2.24.0-beta.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -4706,6 +4706,7 @@ var menus;
 
 
 
+
 /**
  * v2 APIs telemetry file: All of APIs in this capability file should send out API version v2 ONLY
  */
@@ -4982,6 +4983,8 @@ var app;
         GlobalVars.frameContext = undefined;
         GlobalVars.hostClientType = undefined;
         GlobalVars.isFramelessWindow = false;
+        messageChannels.telemetry._clearTelemetryPort();
+        messageChannels.dataLayer._clearDataLayerPort();
         uninitializeCommunication();
     }
     app._uninitialize = _uninitialize;
@@ -6217,6 +6220,60 @@ function handlers_registerOnResumeHandler(handler) {
         ]);
 }
 
+;// CONCATENATED MODULE: ./src/internal/uuidObject.ts
+
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * UUID object
+ */
+class UUID {
+    constructor(uuid = generateGUID()) {
+        this.uuid = uuid;
+        validateUuid(uuid);
+    }
+    toString() {
+        return this.uuid;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/internal/messageObjects.ts
+var messageObjects_rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+const serializeMessageRequest = (message) => {
+    const { uuid } = message, restOfMessage = messageObjects_rest(message, ["uuid"]);
+    const uuidAsString = uuid === null || uuid === void 0 ? void 0 : uuid.toString();
+    const request = Object.assign(Object.assign({}, restOfMessage), { uuidAsString: uuidAsString });
+    return request;
+};
+const deserializeMessageRequest = (message) => {
+    const { uuidAsString } = message, restOfMessage = messageObjects_rest(message, ["uuidAsString"]);
+    const request = Object.assign(Object.assign({}, restOfMessage), { uuid: uuidAsString ? new UUID(uuidAsString) : undefined });
+    return request;
+};
+const deserializeMessageResponse = (serializedResponse) => {
+    const { uuidAsString } = serializedResponse, restOfResponse = messageObjects_rest(serializedResponse, ["uuidAsString"]);
+    const messageResponse = Object.assign(Object.assign({}, restOfResponse), { uuid: uuidAsString ? new UUID(uuidAsString) : undefined });
+    return messageResponse;
+};
+const serializeMessageResponse = (response) => {
+    const { uuid } = response, restOfResponse = messageObjects_rest(response, ["uuid"]);
+    const uuidAsString = uuid === null || uuid === void 0 ? void 0 : uuid.toString();
+    const messageResponse = Object.assign(Object.assign({}, restOfResponse), { uuidAsString: uuidAsString });
+    return messageResponse;
+};
+
 ;// CONCATENATED MODULE: ./src/internal/nestedAppAuthUtils.ts
 
 
@@ -6341,6 +6398,8 @@ var communication_awaiter = (undefined && undefined.__awaiter) || function (this
 
 
 
+
+
 const communicationLogger = getLogger('communication');
 /**
  * @internal
@@ -6358,9 +6417,10 @@ CommunicationPrivate.parentMessageQueue = [];
 CommunicationPrivate.childMessageQueue = [];
 CommunicationPrivate.topMessageQueue = [];
 CommunicationPrivate.nextMessageId = 0;
-CommunicationPrivate.callbacks = {};
-CommunicationPrivate.promiseCallbacks = {};
-CommunicationPrivate.portCallbacks = {};
+CommunicationPrivate.callbacks = new Map();
+CommunicationPrivate.promiseCallbacks = new Map();
+CommunicationPrivate.portCallbacks = new Map();
+CommunicationPrivate.legacyMessageIdsToUuidMap = {};
 /**
  * @internal
  * Limited to Microsoft-internal use
@@ -6428,9 +6488,10 @@ function uninitializeCommunication() {
     CommunicationPrivate.parentMessageQueue = [];
     CommunicationPrivate.childMessageQueue = [];
     CommunicationPrivate.nextMessageId = 0;
-    CommunicationPrivate.callbacks = {};
-    CommunicationPrivate.promiseCallbacks = {};
-    CommunicationPrivate.portCallbacks = {};
+    CommunicationPrivate.callbacks.clear();
+    CommunicationPrivate.promiseCallbacks.clear();
+    CommunicationPrivate.portCallbacks.clear();
+    CommunicationPrivate.legacyMessageIdsToUuidMap = {};
 }
 /**
  * @hidden
@@ -6505,7 +6566,7 @@ function sendMessageToParentAsync(apiVersionTag, actionName, args = undefined) {
     }
     return new Promise((resolve) => {
         const request = sendMessageToParentHelper(apiVersionTag, actionName, args);
-        resolve(waitForResponse(request.id));
+        resolve(waitForResponse(request.uuid));
     });
 }
 /**
@@ -6519,15 +6580,15 @@ function requestPortFromParentWithVersion(apiVersionTag, actionName, args = unde
         throw Error(`apiVersionTag: ${apiVersionTag} passed in doesn't follow the pattern starting with 'v' followed by digits, then underscore with words, please check.`);
     }
     const request = sendMessageToParentHelper(apiVersionTag, actionName, args);
-    return waitForPort(request.id);
+    return waitForPort(request.uuid);
 }
 /**
  * @internal
  * Limited to Microsoft-internal use
  */
-function waitForPort(requestId) {
+function waitForPort(requestUuid) {
     return new Promise((resolve, reject) => {
-        CommunicationPrivate.portCallbacks[requestId] = (port, args) => {
+        CommunicationPrivate.portCallbacks.set(requestUuid, (port, args) => {
             if (port instanceof MessagePort) {
                 resolve(port);
             }
@@ -6535,16 +6596,16 @@ function waitForPort(requestId) {
                 // First arg is the error message, if present
                 reject(args && args.length > 0 ? args[0] : new Error('Host responded without port or error details.'));
             }
-        };
+        });
     });
 }
 /**
  * @internal
  * Limited to Microsoft-internal use
  */
-function waitForResponse(requestId) {
+function waitForResponse(requestUuid) {
     return new Promise((resolve) => {
-        CommunicationPrivate.promiseCallbacks[requestId] = resolve;
+        CommunicationPrivate.promiseCallbacks.set(requestUuid, resolve);
     });
 }
 /**
@@ -6567,9 +6628,7 @@ function sendMessageToParent(apiVersionTag, actionName, argsOrCallback, callback
     }
     const request = sendMessageToParentHelper(apiVersionTag, actionName, args);
     if (callback) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        CommunicationPrivate.callbacks[request.id] = callback;
+        CommunicationPrivate.callbacks.set(request.uuid, callback);
     }
 }
 const sendNestedAuthRequestToTopWindowLogger = communicationLogger.extend('sendNestedAuthRequestToTopWindow');
@@ -6581,7 +6640,7 @@ function sendNestedAuthRequestToTopWindow(message) {
     const logger = sendNestedAuthRequestToTopWindowLogger;
     const targetWindow = Communication.topWindow;
     const request = createNestedAppAuthRequest(message);
-    logger('Message %i information: %o', request.id, { actionName: request.func });
+    logger('Message %i information: %o', request.uuid, { actionName: request.func });
     return sendRequestToTargetWindowHelper(targetWindow, request);
 }
 const sendRequestToTargetWindowHelperLogger = communicationLogger.extend('sendRequestToTargetWindowHelper');
@@ -6589,12 +6648,13 @@ const sendRequestToTargetWindowHelperLogger = communicationLogger.extend('sendRe
  * @internal
  * Limited to Microsoft-internal use
  */
-function sendRequestToTargetWindowHelper(targetWindow, request) {
+function sendRequestToTargetWindowHelper(targetWindow, messageRequest) {
     const logger = sendRequestToTargetWindowHelperLogger;
     const targetWindowName = getTargetName(targetWindow);
+    const request = serializeMessageRequest(messageRequest);
     if (GlobalVars.isFramelessWindow) {
         if (Communication.currentWindow && Communication.currentWindow.nativeInterface) {
-            logger(`Sending message %i to ${targetWindowName} via framelessPostMessage interface`, request.id);
+            logger(`Sending message %i to ${targetWindowName} via framelessPostMessage interface`, request.uuidAsString);
             Communication.currentWindow.nativeInterface.framelessPostMessage(JSON.stringify(request));
         }
     }
@@ -6603,15 +6663,15 @@ function sendRequestToTargetWindowHelper(targetWindow, request) {
         // If the target window isn't closed and we already know its origin, send the message right away; otherwise,
         // queue the message and send it after the origin is established
         if (targetWindow && targetOrigin) {
-            logger(`Sending message %i to ${targetWindowName} via postMessage`, request.id);
+            logger(`Sending message %i to ${targetWindowName} via postMessage`, request.uuidAsString);
             targetWindow.postMessage(request, targetOrigin);
         }
         else {
-            logger(`Adding message %i to ${targetWindowName} message queue`, request.id);
-            getTargetMessageQueue(targetWindow).push(request);
+            logger(`Adding message %i to ${targetWindowName} message queue`, request.uuidAsString);
+            getTargetMessageQueue(targetWindow).push(messageRequest);
         }
     }
-    return request;
+    return messageRequest;
 }
 const sendMessageToParentHelperLogger = communicationLogger.extend('sendMessageToParentHelper');
 /**
@@ -6622,8 +6682,7 @@ function sendMessageToParentHelper(apiVersionTag, actionName, args) {
     const logger = sendMessageToParentHelperLogger;
     const targetWindow = Communication.parentWindow;
     const request = createMessageRequest(apiVersionTag, actionName, args);
-    /* eslint-disable-next-line strict-null-checks/all */ /* Fix tracked by 5730662 */
-    logger('Message %i information: %o', request.id, { actionName, args });
+    logger('Message %i information: %o', request.uuid, { actionName, args });
     return sendRequestToTargetWindowHelper(targetWindow, request);
 }
 const processMessageLogger = communicationLogger.extend('processMessage');
@@ -6787,6 +6846,70 @@ function updateRelationships(messageSource, messageOrigin) {
     flushMessageQueue(Communication.childWindow);
 }
 const handleParentMessageLogger = communicationLogger.extend('handleParentMessage');
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function retrieveMessageUUIDFromResponse(response) {
+    var _a;
+    const logger = handleParentMessageLogger;
+    if (response.uuid) {
+        const responseUUID = response.uuid;
+        const callbackUUID = retrieveMessageUUIDFromCallback(CommunicationPrivate.callbacks, responseUUID);
+        if (callbackUUID) {
+            return callbackUUID;
+        }
+        const promiseCallbackUUID = retrieveMessageUUIDFromCallback(CommunicationPrivate.promiseCallbacks, responseUUID);
+        if (promiseCallbackUUID) {
+            return promiseCallbackUUID;
+        }
+        const portCallbackUUID = retrieveMessageUUIDFromCallback(CommunicationPrivate.portCallbacks, responseUUID);
+        if (portCallbackUUID) {
+            return portCallbackUUID;
+        }
+    }
+    else {
+        return CommunicationPrivate.legacyMessageIdsToUuidMap[response.id];
+    }
+    logger(`Received a message with uuid: ${(_a = response.uuid) === null || _a === void 0 ? void 0 : _a.toString()} and legacyId: %i that failed to produce a callbackId`, response.id);
+    return undefined;
+}
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ *
+ * This function is used to compare a new MessageUUID object value to the key values in the specified callback and retrieving that key
+ * We use this because two objects with the same value are not considered equivalent therefore we can't use the new MessageUUID object
+ * as a key to retrieve the value assosciated with it and should use this function instead.
+ */
+function retrieveMessageUUIDFromCallback(map, responseUUID) {
+    if (responseUUID) {
+        const callback = [...map].find(([key, _value]) => {
+            return key.toString() === responseUUID.toString();
+        });
+        if (callback) {
+            return callback[0];
+        }
+    }
+    return undefined;
+}
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function removeMessageHandlers(message, map) {
+    const callbackId = retrieveMessageUUIDFromCallback(map, message.uuid);
+    if (callbackId) {
+        map.delete(callbackId);
+    }
+    if (!message.uuid) {
+        delete CommunicationPrivate.legacyMessageIdsToUuidMap[message.id];
+    }
+    else {
+        //If we are here, then the parent is capable of sending UUIDs, therefore free up memory
+        CommunicationPrivate.legacyMessageIdsToUuidMap = {};
+    }
+}
 /**
  * @internal
  * Limited to Microsoft-internal use
@@ -6795,37 +6918,44 @@ function handleParentMessage(evt) {
     const logger = handleParentMessageLogger;
     if ('id' in evt.data && typeof evt.data.id === 'number') {
         // Call any associated Communication.callbacks
-        const message = evt.data;
-        const callback = CommunicationPrivate.callbacks[message.id];
-        logger('Received a response from parent for message %i', message.id);
-        if (callback) {
-            logger('Invoking the registered callback for message %i with arguments %o', message.id, message.args);
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            callback.apply(null, [...message.args, message.isPartialResponse]);
-            // Remove the callback to ensure that the callback is called only once and to free up memory if response is a complete response
-            if (!isPartialResponse(evt)) {
-                logger('Removing registered callback for message %i', message.id);
-                delete CommunicationPrivate.callbacks[message.id];
+        const serializedResponse = evt.data;
+        const message = deserializeMessageResponse(serializedResponse);
+        const callbackId = retrieveMessageUUIDFromResponse(message);
+        if (callbackId) {
+            const callback = CommunicationPrivate.callbacks.get(callbackId);
+            logger('Received a response from parent for message %i', callbackId);
+            if (callback) {
+                logger('Invoking the registered callback for message %i with arguments %o', callbackId, message.args);
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                callback.apply(null, [...message.args, message.isPartialResponse]);
+                // Remove the callback to ensure that the callback is called only once and to free up memory if response is a complete response
+                if (!isPartialResponse(evt)) {
+                    logger('Removing registered callback for message %i', callbackId);
+                    removeMessageHandlers(message, CommunicationPrivate.callbacks);
+                }
             }
-        }
-        const promiseCallback = CommunicationPrivate.promiseCallbacks[message.id];
-        if (promiseCallback) {
-            logger('Invoking the registered promise callback for message %i with arguments %o', message.id, message.args);
-            promiseCallback(message.args);
-            logger('Removing registered promise callback for message %i', message.id);
-            delete CommunicationPrivate.promiseCallbacks[message.id];
-        }
-        const portCallback = CommunicationPrivate.portCallbacks[message.id];
-        if (portCallback) {
-            logger('Invoking the registered port callback for message %i with arguments %o', message.id, message.args);
-            let port;
-            if (evt.ports && evt.ports[0] instanceof MessagePort) {
-                port = evt.ports[0];
+            const promiseCallback = CommunicationPrivate.promiseCallbacks.get(callbackId);
+            if (promiseCallback) {
+                logger('Invoking the registered promise callback for message %i with arguments %o', callbackId, message.args);
+                promiseCallback(message.args);
+                logger('Removing registered promise callback for message %i', callbackId);
+                removeMessageHandlers(message, CommunicationPrivate.promiseCallbacks);
+            }
+            const portCallback = CommunicationPrivate.portCallbacks.get(callbackId);
+            if (portCallback) {
+                logger('Invoking the registered port callback for message %i with arguments %o', callbackId, message.args);
+                let port;
+                if (evt.ports && evt.ports[0] instanceof MessagePort) {
+                    port = evt.ports[0];
+                }
+                portCallback(port, message.args);
+                logger('Removing registered port callback for message %i', callbackId);
+                removeMessageHandlers(message, CommunicationPrivate.portCallbacks);
+            }
+            if (message.uuid) {
+                CommunicationPrivate.legacyMessageIdsToUuidMap = {};
             }
-            portCallback(port, message.args);
-            logger('Removing registered port callback for message %i', message.id);
-            delete CommunicationPrivate.portCallbacks[message.id];
         }
     }
     else if ('func' in evt.data && typeof evt.data.func === 'string') {
@@ -6852,12 +6982,12 @@ function isPartialResponse(evt) {
 function handleChildMessage(evt) {
     if ('id' in evt.data && 'func' in evt.data) {
         // Try to delegate the request to the proper handler, if defined
-        const message = evt.data;
+        const message = deserializeMessageRequest(evt.data);
         const [called, result] = callHandler(message.func, message.args);
         if (called && typeof result !== 'undefined') {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
-            sendMessageResponseToChild(message.id, Array.isArray(result) ? result : [result]);
+            sendMessageResponseToChild(message.id, message.uuid, Array.isArray(result) ? result : [result]);
         }
         else {
             // No handler, proxy to parent
@@ -6866,7 +6996,7 @@ function handleChildMessage(evt) {
                     const isPartialResponse = args.pop();
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    sendMessageResponseToChild(message.id, args, isPartialResponse);
+                    sendMessageResponseToChild(message.id, message.uuid, args, isPartialResponse);
                 }
             });
         }
@@ -6947,10 +7077,13 @@ function flushMessageQueue(targetWindow) {
     const targetMessageQueue = getTargetMessageQueue(targetWindow);
     const target = getTargetName(targetWindow);
     while (targetWindow && targetOrigin && targetMessageQueue.length > 0) {
-        const request = targetMessageQueue.shift();
-        /* eslint-disable-next-line strict-null-checks/all */ /* Fix tracked by 5730662 */
-        flushMessageQueueLogger('Flushing message %i from ' + target + ' message queue via postMessage.', request === null || request === void 0 ? void 0 : request.id);
-        targetWindow.postMessage(request, targetOrigin);
+        const messageRequest = targetMessageQueue.shift();
+        if (messageRequest) {
+            const request = serializeMessageRequest(messageRequest);
+            /* eslint-disable-next-line strict-null-checks/all */ /* Fix tracked by 5730662 */
+            flushMessageQueueLogger('Flushing message %i from ' + target + ' message queue via postMessage.', request === null || request === void 0 ? void 0 : request.uuidAsString);
+            targetWindow.postMessage(request, targetOrigin);
+        }
     }
 }
 /**
@@ -6976,12 +7109,13 @@ function waitForMessageQueue(targetWindow, callback) {
  * @internal
  * Limited to Microsoft-internal use
  */
-function sendMessageResponseToChild(id, args, isPartialResponse) {
+function sendMessageResponseToChild(id, uuid, args, isPartialResponse) {
     const targetWindow = Communication.childWindow;
-    const response = createMessageResponse(id, args, isPartialResponse);
+    const response = createMessageResponse(id, uuid, args, isPartialResponse);
+    const serializedResponse = serializeMessageResponse(response);
     const targetOrigin = getTargetOrigin(targetWindow);
     if (targetWindow && targetOrigin) {
-        targetWindow.postMessage(response, targetOrigin);
+        targetWindow.postMessage(serializedResponse, targetOrigin);
     }
 }
 /**
@@ -7011,8 +7145,12 @@ function sendMessageEventToChild(actionName, args) {
  * Limited to Microsoft-internal use
  */
 function createMessageRequest(apiVersionTag, func, args) {
+    const messageId = CommunicationPrivate.nextMessageId++;
+    const messageUuid = new UUID();
+    CommunicationPrivate.legacyMessageIdsToUuidMap[messageId] = messageUuid;
     return {
-        id: CommunicationPrivate.nextMessageId++,
+        id: messageId,
+        uuid: messageUuid,
         func: func,
         timestamp: Date.now(),
         args: args || [],
@@ -7031,8 +7169,12 @@ function createMessageRequest(apiVersionTag, func, args) {
  * @returns {NestedAppAuthRequest} Returns a NestedAppAuthRequest object with a unique id, the function name set to 'nestedAppAuthRequest', the current timestamp, an empty args array, and the provided message as data.
  */
 function createNestedAppAuthRequest(message) {
+    const messageId = CommunicationPrivate.nextMessageId++;
+    const messageUuid = new UUID();
+    CommunicationPrivate.legacyMessageIdsToUuidMap[messageId] = messageUuid;
     return {
-        id: CommunicationPrivate.nextMessageId++,
+        id: messageId,
+        uuid: messageUuid,
         func: 'nestedAppAuth.execute',
         timestamp: Date.now(),
         // Since this is a nested app auth request, we don't need to send any args.
@@ -7045,9 +7187,10 @@ function createNestedAppAuthRequest(message) {
  * @internal
  * Limited to Microsoft-internal use
  */
-function createMessageResponse(id, args, isPartialResponse) {
+function createMessageResponse(id, uuid, args, isPartialResponse) {
     return {
         id: id,
+        uuid: uuid,
         args: args || [],
         isPartialResponse,
     };