@microsoft/teams-js 2.34.0-beta.0 → 2.34.0

package/dist/umd/MicrosoftTeams.js

@@ -1353,6 +1353,7 @@ __webpack_require__.d(conversations_namespaceObject, {
 var customTelemetry_namespaceObject = {};
 __webpack_require__.r(customTelemetry_namespaceObject);
 __webpack_require__.d(customTelemetry_namespaceObject, {
+  isSupported: () => (customTelemetry_isSupported),
   sendCustomTelemetryData: () => (sendCustomTelemetryData)
 });
 
@@ -1771,12 +1772,21 @@ __webpack_require__.d(calendar_namespaceObject, {
   openCalendarItem: () => (openCalendarItem)
 });
 
-// NAMESPACE OBJECT: ./src/public/mail.ts
+// NAMESPACE OBJECT: ./src/public/mail/handoff.ts
+var handoff_namespaceObject = {};
+__webpack_require__.r(handoff_namespaceObject);
+__webpack_require__.d(handoff_namespaceObject, {
+  composeMailWithHandoff: () => (composeMailWithHandoff),
+  isSupported: () => (handoff_isSupported)
+});
+
+// NAMESPACE OBJECT: ./src/public/mail/mail.ts
 var mail_namespaceObject = {};
 __webpack_require__.r(mail_namespaceObject);
 __webpack_require__.d(mail_namespaceObject, {
   ComposeMailType: () => (ComposeMailType),
   composeMail: () => (composeMail),
+  handoff: () => (handoff_namespaceObject),
   isSupported: () => (mail_isSupported),
   openMailItem: () => (openMailItem)
 });
@@ -3146,6 +3156,8 @@ var HostClientType;
     HostClientType["ipados"] = "ipados";
     /** The host is running on a macOS client, which runs on devices such as MacBooks. */
     HostClientType["macos"] = "macos";
+    /** The host is running on a visionOS client, which runs on devices such as Apple Vision. */
+    HostClientType["visionOS"] = "visionOS";
     /**
      * @deprecated
      * As of TeamsJS v2.0.0, please use {@link teamsRoomsWindows} instead.
@@ -4003,6 +4015,14 @@ const validOriginsLocal = artifactsForCDN_validDomains_namespaceObject;
  * Limited to Microsoft-internal use
  */
 const validOriginsFallback = validOriginsLocal.validOrigins;
+/**
+ * @hidden
+ * Timeout length for Fetch Call for Valid Origins
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+const ORIGIN_LIST_FETCH_TIMEOUT_IN_MS = 1500;
 /**
  * @hidden
  * CDN endpoint of the list of valid origins
@@ -4178,7 +4198,12 @@ const v1NonMobileHostClientTypes = [
     HostClientType.teamsPhones,
     HostClientType.teamsDisplays,
 ];
-const v1MobileHostClientTypes = [HostClientType.android, HostClientType.ios, HostClientType.ipados];
+const v1MobileHostClientTypes = [
+    HostClientType.android,
+    HostClientType.ios,
+    HostClientType.ipados,
+    HostClientType.visionOS,
+];
 const v1HostClientTypes = [...v1NonMobileHostClientTypes, ...v1MobileHostClientTypes];
 /**
  * @hidden
@@ -4328,7 +4353,7 @@ const mapTeamsVersionToSupportedCapabilities = {
     '2.1.1': [
         {
             capability: { nestedAppAuth: {} },
-            hostClientTypes: [HostClientType.android, HostClientType.ios, HostClientType.ipados],
+            hostClientTypes: [HostClientType.android, HostClientType.ios, HostClientType.ipados, HostClientType.visionOS],
         },
     ],
 };
@@ -4460,7 +4485,7 @@ function isSerializable(arg) {
  * @hidden
  *  Package version.
  */
-const version = "2.34.0-beta.0";
+const version = "2.34.0";
 
 ;// ./src/internal/internalAPIs.ts
 
@@ -4539,7 +4564,7 @@ function isCurrentSDKVersionAtLeast(requiredVersion = defaultSDKVersionForCompat
 }
 /**
  * @hidden
- * Helper function to identify if host client is either android, ios, or ipados
+ * Helper function to identify if host client is either android, ios, ipados, or visionOS
  *
  * @internal
  * Limited to Microsoft-internal use
@@ -4547,7 +4572,8 @@ function isCurrentSDKVersionAtLeast(requiredVersion = defaultSDKVersionForCompat
 function isHostClientMobile() {
     return (GlobalVars.hostClientType == HostClientType.android ||
         GlobalVars.hostClientType == HostClientType.ios ||
-        GlobalVars.hostClientType == HostClientType.ipados);
+        GlobalVars.hostClientType == HostClientType.ipados ||
+        GlobalVars.hostClientType == HostClientType.visionOS);
 }
 /**
  * @hidden
@@ -4687,139 +4713,8 @@ function isNullOrUndefined(value) {
     return value === null || value === undefined;
 }
 
-;// ./src/internal/validOrigins.ts
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-
-
-
-
-let validOriginsCache = [];
-const validateOriginLogger = getLogger('validateOrigin');
-function prefetchOriginsFromCDN() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield getValidOriginsListFromCDN();
-    });
-}
-function isValidOriginsCacheEmpty() {
-    return validOriginsCache.length === 0;
-}
-function getValidOriginsListFromCDN() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!isValidOriginsCacheEmpty()) {
-            return validOriginsCache;
-        }
-        if (!inServerSideRenderingEnvironment()) {
-            return fetch(validOriginsCdnEndpoint)
-                .then((response) => {
-                if (!response.ok) {
-                    throw new Error('Invalid Response from Fetch Call');
-                }
-                return response.json().then((validOriginsCDN) => {
-                    if (isValidOriginsJSONValid(JSON.stringify(validOriginsCDN))) {
-                        validOriginsCache = validOriginsCDN.validOrigins;
-                        return validOriginsCache;
-                    }
-                    else {
-                        throw new Error('Valid Origins List Is Invalid');
-                    }
-                });
-            })
-                .catch((e) => {
-                validateOriginLogger('validOrigins fetch call to CDN failed with error: %s. Defaulting to fallback list', e);
-                validOriginsCache = validOriginsFallback;
-                return validOriginsCache;
-            });
-        }
-        else {
-            validOriginsCache = validOriginsFallback;
-            return validOriginsFallback;
-        }
-    });
-}
-function isValidOriginsJSONValid(validOriginsJSON) {
-    let validOriginsCDN = JSON.parse(validOriginsJSON);
-    try {
-        validOriginsCDN = JSON.parse(validOriginsJSON);
-    }
-    catch (_) {
-        return false;
-    }
-    if (!validOriginsCDN.validOrigins) {
-        return false;
-    }
-    for (const validOrigin of validOriginsCDN.validOrigins) {
-        try {
-            new URL('https://' + validOrigin);
-        }
-        catch (_) {
-            validateOriginLogger('isValidOriginsFromCDN call failed to validate origin: %s', validOrigin);
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * @param pattern - reference pattern
- * @param host - candidate string
- * @returns returns true if host matches pre-know valid pattern
- *
- * @example
- *    validateHostAgainstPattern('*.teams.microsoft.com', 'subdomain.teams.microsoft.com') returns true
- *    validateHostAgainstPattern('teams.microsoft.com', 'team.microsoft.com') returns false
- *
- * @internal
- * Limited to Microsoft-internal use
- */
-function validateHostAgainstPattern(pattern, host) {
-    if (pattern.substring(0, 2) === '*.') {
-        const suffix = pattern.substring(1);
-        if (host.length > suffix.length &&
-            host.split('.').length === suffix.split('.').length &&
-            host.substring(host.length - suffix.length) === suffix) {
-            return true;
-        }
-    }
-    else if (pattern === host) {
-        return true;
-    }
-    return false;
-}
-/**
- * @internal
- * Limited to Microsoft-internal use
- */
-function validateOrigin(messageOrigin) {
-    return getValidOriginsListFromCDN().then((validOriginsList) => {
-        // Check whether the url is in the pre-known allowlist or supplied by user
-        if (!isValidHttpsURL(messageOrigin)) {
-            validateOriginLogger('Origin %s is invalid because it is not using https protocol. Protocol being used: %s', messageOrigin, messageOrigin.protocol);
-            return false;
-        }
-        const messageOriginHost = messageOrigin.host;
-        if (validOriginsList.some((pattern) => validateHostAgainstPattern(pattern, messageOriginHost))) {
-            return true;
-        }
-        for (const domainOrPattern of GlobalVars.additionalValidOrigins) {
-            const pattern = domainOrPattern.substring(0, 8) === 'https://' ? domainOrPattern.substring(8) : domainOrPattern;
-            if (validateHostAgainstPattern(pattern, messageOriginHost)) {
-                return true;
-            }
-        }
-        validateOriginLogger('Origin %s is invalid because it is not an origin approved by this library or included in the call to app.initialize.\nOrigins approved by this library: %o\nOrigins included in app.initialize: %o', messageOrigin, validOriginsList, GlobalVars.additionalValidOrigins);
-        return false;
-    });
-}
-
 ;// ./src/private/messageChannels/telemetry.ts
-var telemetry_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -4851,7 +4746,7 @@ const logger = getLogger('messageChannels.telemetry');
  * Limited to Microsoft-internal use
  */
 function getTelemetryPort() {
-    return telemetry_awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         // If the port has already been initialized, return it.
         if (telemetryPort) {
             logger('Returning telemetry port from cache');
@@ -5145,7 +5040,6 @@ logWhereTeamsJsIsBeingUsed();
  * @returns Promise that will be fulfilled when initialization has completed, or rejected if the initialization fails or times out
  */
 function initialize(validMessageOrigins) {
-    prefetchOriginsFromCDN();
     return appInitializeHelper(getApiVersionTag(appTelemetryVersionNumber, "app.initialize" /* ApiName.App_Initialize */), validMessageOrigins);
 }
 /**
@@ -5309,6 +5203,8 @@ function transformLegacyContextToAppContext(legacyContext) {
                 ringId: legacyContext.ringId,
             },
             appLaunchId: legacyContext.appLaunchId,
+            appId: legacyContext.appId ? new AppId(legacyContext.appId) : undefined,
+            manifestVersion: legacyContext.manifestVersion,
         },
         page: {
             id: legacyContext.entityId,
@@ -6808,6 +6704,148 @@ function openLinkHelper(apiVersionTag, deepLink) {
     });
 }
 
+;// ./src/internal/validOrigins.ts
+var validOrigins_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+
+
+
+
+let validOriginsCache = [];
+const validateOriginLogger = getLogger('validateOrigin');
+function prefetchOriginsFromCDN() {
+    return validOrigins_awaiter(this, void 0, void 0, function* () {
+        yield getValidOriginsListFromCDN();
+    });
+}
+function isValidOriginsCacheEmpty() {
+    return validOriginsCache.length === 0;
+}
+function getValidOriginsListFromCDN(shouldDisableCache = false) {
+    return validOrigins_awaiter(this, void 0, void 0, function* () {
+        if (!isValidOriginsCacheEmpty() && !shouldDisableCache) {
+            return validOriginsCache;
+        }
+        if (!inServerSideRenderingEnvironment()) {
+            validateOriginLogger('Initiating fetch call to acquire valid origins list from CDN');
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), ORIGIN_LIST_FETCH_TIMEOUT_IN_MS);
+            return fetch(validOriginsCdnEndpoint, { signal: controller.signal })
+                .then((response) => {
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error('Invalid Response from Fetch Call');
+                }
+                validateOriginLogger('Fetch call completed and retrieved valid origins list from CDN');
+                return response.json().then((validOriginsCDN) => {
+                    if (isValidOriginsJSONValid(JSON.stringify(validOriginsCDN))) {
+                        validOriginsCache = validOriginsCDN.validOrigins;
+                        return validOriginsCache;
+                    }
+                    else {
+                        throw new Error('Valid origins list retrieved from CDN is invalid');
+                    }
+                });
+            })
+                .catch((e) => {
+                if (e.name === 'AbortError') {
+                    validateOriginLogger(`validOrigins fetch call to CDN failed due to Timeout of ${ORIGIN_LIST_FETCH_TIMEOUT_IN_MS} ms. Defaulting to fallback list`);
+                }
+                else {
+                    validateOriginLogger('validOrigins fetch call to CDN failed with error: %s. Defaulting to fallback list', e);
+                }
+                validOriginsCache = validOriginsFallback;
+                return validOriginsCache;
+            });
+        }
+        else {
+            validOriginsCache = validOriginsFallback;
+            return validOriginsFallback;
+        }
+    });
+}
+function isValidOriginsJSONValid(validOriginsJSON) {
+    let validOriginsCDN = JSON.parse(validOriginsJSON);
+    try {
+        validOriginsCDN = JSON.parse(validOriginsJSON);
+    }
+    catch (_) {
+        return false;
+    }
+    if (!validOriginsCDN.validOrigins) {
+        return false;
+    }
+    for (const validOrigin of validOriginsCDN.validOrigins) {
+        try {
+            new URL('https://' + validOrigin);
+        }
+        catch (_) {
+            validateOriginLogger('isValidOriginsFromCDN call failed to validate origin: %s', validOrigin);
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @param pattern - reference pattern
+ * @param host - candidate string
+ * @returns returns true if host matches pre-know valid pattern
+ *
+ * @example
+ *    validateHostAgainstPattern('*.teams.microsoft.com', 'subdomain.teams.microsoft.com') returns true
+ *    validateHostAgainstPattern('teams.microsoft.com', 'team.microsoft.com') returns false
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateHostAgainstPattern(pattern, host) {
+    if (pattern.substring(0, 2) === '*.') {
+        const suffix = pattern.substring(1);
+        if (host.length > suffix.length &&
+            host.split('.').length === suffix.split('.').length &&
+            host.substring(host.length - suffix.length) === suffix) {
+            return true;
+        }
+    }
+    else if (pattern === host) {
+        return true;
+    }
+    return false;
+}
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function validateOrigin(messageOrigin, disableCache) {
+    return getValidOriginsListFromCDN(disableCache).then((validOriginsList) => {
+        // Check whether the url is in the pre-known allowlist or supplied by user
+        if (!isValidHttpsURL(messageOrigin)) {
+            validateOriginLogger('Origin %s is invalid because it is not using https protocol. Protocol being used: %s', messageOrigin, messageOrigin.protocol);
+            return false;
+        }
+        const messageOriginHost = messageOrigin.host;
+        if (validOriginsList.some((pattern) => validateHostAgainstPattern(pattern, messageOriginHost))) {
+            return true;
+        }
+        for (const domainOrPattern of GlobalVars.additionalValidOrigins) {
+            const pattern = domainOrPattern.substring(0, 8) === 'https://' ? domainOrPattern.substring(8) : domainOrPattern;
+            if (validateHostAgainstPattern(pattern, messageOriginHost)) {
+                return true;
+            }
+        }
+        validateOriginLogger('Origin %s is invalid because it is not an origin approved by this library or included in the call to app.initialize.\nOrigins approved by this library: %o\nOrigins included in app.initialize: %o', messageOrigin, validOriginsList, GlobalVars.additionalValidOrigins);
+        return false;
+    });
+}
+prefetchOriginsFromCDN();
+
 ;// ./src/public/pages/appButton.ts
 /**
  * Provides APIs to interact with the app button part of the SDK.
@@ -8344,10 +8382,10 @@ const sendMessageToParentHelperLogger = communicationLogger.extend('sendMessageT
  * @internal
  * Limited to Microsoft-internal use
  */
-function sendMessageToParentHelper(apiVersionTag, actionName, args) {
+function sendMessageToParentHelper(apiVersionTag, actionName, args, isProxiedFromChild) {
     const logger = sendMessageToParentHelperLogger;
     const targetWindow = Communication.parentWindow;
-    const request = createMessageRequest(apiVersionTag, actionName, args);
+    const request = createMessageRequest(apiVersionTag, actionName, args, isProxiedFromChild);
     HostToAppMessageDelayTelemetry.storeCallbackInformation(request.uuid, {
         name: actionName,
         calledAt: request.timestamp,
@@ -8674,15 +8712,7 @@ function handleIncomingMessageFromChild(evt) {
         else {
             // No handler, proxy to parent
             handleIncomingMessageFromChildLogger('No handler for message %s from child found; relaying message on to parent, action: %s. Relayed message will have a new id.', getMessageIdsAsLogString(message), message.func);
-            sendMessageToParent(getApiVersionTag("v2" /* ApiVersionNumber.V_2 */, "tasks.startTask" /* ApiName.Tasks_StartTask */), message.func, message.args, (...args) => {
-                if (Communication.childWindow) {
-                    const isPartialResponse = args.pop();
-                    handleIncomingMessageFromChildLogger('Message from parent being relayed to child, id: %s', getMessageIdsAsLogString(message));
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore
-                    sendMessageResponseToChild(message.id, message.uuid, args, isPartialResponse);
-                }
-            });
+            proxyChildMessageToParent(message);
         }
     }
 }
@@ -8829,7 +8859,7 @@ function sendMessageEventToChild(actionName, args) {
  * @internal
  * Limited to Microsoft-internal use
  */
-function createMessageRequest(apiVersionTag, func, args) {
+function createMessageRequest(apiVersionTag, func, args, isProxiedFromChild) {
     const messageId = CommunicationPrivate.nextMessageId++;
     const messageUuid = new UUID();
     CommunicationPrivate.legacyMessageIdsToUuidMap[messageId] = messageUuid;
@@ -8841,6 +8871,7 @@ function createMessageRequest(apiVersionTag, func, args) {
         monotonicTimestamp: getCurrentTimestamp(),
         args: args || [],
         apiVersionTag: apiVersionTag,
+        isProxiedFromChild: isProxiedFromChild !== null && isProxiedFromChild !== void 0 ? isProxiedFromChild : false,
     };
 }
 /**
@@ -8906,6 +8937,22 @@ function getMessageIdsAsLogString(message) {
         return `legacy id: ${message.id} (no uuid)`;
     }
 }
+/**
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+function proxyChildMessageToParent(message) {
+    const request = sendMessageToParentHelper(getApiVersionTag("v2" /* ApiVersionNumber.V_2 */, "tasks.startTask" /* ApiName.Tasks_StartTask */), message.func, message.args, true);
+    CommunicationPrivate.callbacks.set(request.uuid, (...args) => {
+        if (Communication.childWindow) {
+            const isPartialResponse = args.pop();
+            handleIncomingMessageFromChildLogger('Message from parent being relayed to child, id: %s', getMessageIdsAsLogString(message));
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            sendMessageResponseToChild(message.id, message.uuid, args, isPartialResponse);
+        }
+    });
+}
 
 ;// ./src/private/logs.ts
 /**
@@ -9289,6 +9336,19 @@ var customTelemetry_awaiter = (undefined && undefined.__awaiter) || function (th
 
 const copilotTelemetryVersionNumber = "v2" /* ApiVersionNumber.V_2 */;
 const copilotLogger = getLogger('copilot');
+/**
+ * @hidden
+ * @internal
+ * Limited to Microsoft-internal use
+ * @beta
+ * @returns boolean to represent whether copilot.customTelemetry capability is supported
+ *
+ * @throws Error if {@linkcode app.initialize} has not successfully completed
+ */
+function customTelemetry_isSupported() {
+    var _a;
+    return ensureInitialized(runtime) && !!((_a = runtime.supports.copilot) === null || _a === void 0 ? void 0 : _a.customTelemetry);
+}
 /**
  * Sends custom telemetry data to the host.
  *
@@ -14318,16 +14378,17 @@ function isNAAChannelRecommended() {
 }
 function isNAAChannelRecommendedForLegacyTeamsMobile() {
     return ensureInitialized(runtime) &&
-        isHostAndroidOrIOSOrIPadOS() &&
+        isHostAndroidOrIOSOrIPadOSOrVisionOS() &&
         runtime.isLegacyTeams &&
         runtime.supports.nestedAppAuth
         ? true
         : false;
 }
-function isHostAndroidOrIOSOrIPadOS() {
+function isHostAndroidOrIOSOrIPadOSOrVisionOS() {
     return (GlobalVars.hostClientType === HostClientType.android ||
         GlobalVars.hostClientType === HostClientType.ios ||
-        GlobalVars.hostClientType === HostClientType.ipados);
+        GlobalVars.hostClientType === HostClientType.ipados ||
+        GlobalVars.hostClientType === HostClientType.visionOS);
 }
 
 ;// ./src/public/geoLocation/map.ts
@@ -15559,20 +15620,116 @@ function calendar_isSupported() {
     return ensureInitialized(runtime) && runtime.supports.calendar ? true : false;
 }
 
-;// ./src/public/mail.ts
+;// ./src/public/mail/handoff.ts
 /**
  * Used to interact with mail capability, including opening and composing mail.
  * @module
+ *
+ * @beta
  */
 
 
 
 
 
+
+
 /**
  * v2 APIs telemetry file: All of APIs in this capability file should send out API version v2 ONLY
  */
 const mailTelemetryVersionNumber = "v2" /* ApiVersionNumber.V_2 */;
+/**
+ * Validates an array of email addresses.
+ * For ComposeMailType.New, it is valid to pass empty arrays for toRecipients, ccRecipients, and bccRecipients.
+ * This will result in a new email with handed-off (pre-populated) body content but no pre-populated recipients.
+ *
+ * @param emails - An optional array of email addresses to validate.
+ * @throws Error with a message describing if the email address is invalid.
+ *
+ * @beta
+ */
+function validateEmails(emails) {
+    if (!emails || emails.length === 0) {
+        return; // If the array is undefined or empty, consider it valid
+    }
+    // Use validateEmailAddress for each email in the param
+    emails.forEach((email) => {
+        validateEmailAddress(email); // This will throw an error if the email is invalid
+    });
+}
+/**
+ * Validates email addresses in the given ComposeMailParams object.
+ * Validates `toRecipients`, `ccRecipients`, and `bccRecipients` for `ComposeNewParams`.
+ *
+ * @param params - The incoming ComposeMailParams object.
+ * @throws Error with a message describing if the email address is invalid.
+ *
+ * @beta
+ */
+function validateHandoffComposeMailParams(param) {
+    if (!param.handoffId || param.handoffId.trim().length == 0 || param.handoffId.trim() === '') {
+        throw new Error('handoffId should not be null or empty string.');
+    }
+    const composeMailParams = param.composeMailParams;
+    if (composeMailParams.type === ComposeMailType.New) {
+        validateEmails(composeMailParams.toRecipients);
+        validateEmails(composeMailParams.ccRecipients);
+        validateEmails(composeMailParams.bccRecipients);
+    }
+    // For Reply, ReplyAll, and Forward types, no validation needed
+}
+/**
+ * Compose a new email in the user's mailbox, opening it in the drafts UX instead of the standard email.
+ *
+ * @param composeMailParamsWithHandoff - Object that specifies the type of mail item to compose and the details of the mail item.
+ * @returns { Promise<void> } - promise resolves after the compose window has opened successfully in host SDK.
+ * @throws Error with a message describing whether the capability is not initialized or the input is invalid.
+ *
+ * @beta
+ */
+function composeMailWithHandoff(composeMailParamsWithHandoff) {
+    ensureInitialized(runtime, FrameContexts.content);
+    if (!handoff_isSupported()) {
+        throw new Error('Not supported');
+    }
+    validateHandoffComposeMailParams(composeMailParamsWithHandoff);
+    return callFunctionInHost("mail.handoff.composeMail" /* ApiName.Mail_Handoff_ComposeMail */, [new SerializableComposeMailParamsWithHandoff(composeMailParamsWithHandoff)], getApiVersionTag(mailTelemetryVersionNumber, "mail.handoff.composeMail" /* ApiName.Mail_Handoff_ComposeMail */));
+}
+/**
+ * Checks if the mail capability and handoff sub-capability is supported by the host
+ * @returns boolean to represent whether the handoff sub-capability is supported
+ *
+ * @throws Error if {@linkcode app.initialize} has not successfully completed
+ *
+ * @beta
+ */
+function handoff_isSupported() {
+    return ensureInitialized(runtime) && runtime.supports.mail && runtime.supports.mail.handoff ? true : false;
+}
+class SerializableComposeMailParamsWithHandoff {
+    constructor(composeMailParamsWithHandoff) {
+        this.composeMailParamsWithHandoff = composeMailParamsWithHandoff;
+    }
+    serialize() {
+        return this.composeMailParamsWithHandoff;
+    }
+}
+
+;// ./src/public/mail/mail.ts
+/**
+ * Used to interact with mail capability, including opening and composing mail.
+ * @module
+ */
+
+
+
+
+
+
+/**
+ * v2 APIs telemetry file: All of APIs in this capability file should send out API version v2 ONLY
+ */
+const mail_mailTelemetryVersionNumber = "v2" /* ApiVersionNumber.V_2 */;
 /**
  * Opens a mail message in the host.
  *
@@ -15587,7 +15744,7 @@ function openMailItem(openMailItemParams) {
         if (!openMailItemParams.itemId || !openMailItemParams.itemId.trim()) {
             throw new Error('Must supply an itemId to openMailItem');
         }
-        resolve(sendAndHandleStatusAndReason(getApiVersionTag(mailTelemetryVersionNumber, "mail.openMailItem" /* ApiName.Mail_OpenMailItem */), 'mail.openMailItem', openMailItemParams));
+        resolve(sendAndHandleStatusAndReason(getApiVersionTag(mail_mailTelemetryVersionNumber, "mail.openMailItem" /* ApiName.Mail_OpenMailItem */), 'mail.openMailItem', openMailItemParams));
     });
 }
 /**
@@ -15602,7 +15759,7 @@ function composeMail(composeMailParams) {
         if (!mail_isSupported()) {
             throw new Error('Not supported');
         }
-        resolve(sendAndHandleStatusAndReason(getApiVersionTag(mailTelemetryVersionNumber, "mail.composeMail" /* ApiName.Mail_ComposeMail */), 'mail.composeMail', composeMailParams));
+        resolve(sendAndHandleStatusAndReason(getApiVersionTag(mail_mailTelemetryVersionNumber, "mail.composeMail" /* ApiName.Mail_ComposeMail */), 'mail.composeMail', composeMailParams));
     });
 }
 /**
@@ -15626,6 +15783,7 @@ var ComposeMailType;
     /** Compose a new mail message with the content of an existing mail message forwarded to a new recipient. */
     ComposeMailType["Forward"] = "forward";
 })(ComposeMailType || (ComposeMailType = {}));
+
 
 ;// ./src/public/teamsAPIs.ts
 /**
@@ -16619,7 +16777,8 @@ function isWebStorageClearedOnUserLogOut() {
         if (runtime.isLegacyTeams &&
             (GlobalVars.hostClientType === HostClientType.android ||
                 GlobalVars.hostClientType === HostClientType.ios ||
-                GlobalVars.hostClientType === HostClientType.ipados) &&
+                GlobalVars.hostClientType === HostClientType.ipados ||
+                GlobalVars.hostClientType === HostClientType.visionOS) &&
             (yield getHostName()) === HostName.teams) {
             // On Teams Mobile, they haven't yet implemented this capability. However, for compatibility reasons, we need
             // to act as if they do. If they did implement it, they would return true, so that's what we do here.