@microsoft/teams-js 2.17.1-beta.2 → 2.18.0-beta.0

package/dist/MicrosoftTeams.js

@@ -834,6 +834,8 @@ __webpack_require__.d(__webpack_exports__, {
   dialog: () => (/* reexport */ dialog),
   enablePrintCapability: () => (/* reexport */ enablePrintCapability),
   executeDeepLink: () => (/* reexport */ executeDeepLink),
+  externalAppAuthentication: () => (/* reexport */ externalAppAuthentication),
+  externalAppCardActions: () => (/* reexport */ externalAppCardActions),
   files: () => (/* reexport */ files),
   geoLocation: () => (/* reexport */ geoLocation),
   getAdaptiveCardSchemaVersion: () => (/* reexport */ getAdaptiveCardSchemaVersion),
@@ -1371,6 +1373,9 @@ var SecondaryM365ContentIdName;
     /** User ID */
     SecondaryM365ContentIdName["UserId"] = "userId";
 })(SecondaryM365ContentIdName || (SecondaryM365ContentIdName = {}));
+function isSdkError(err) {
+    return (err === null || err === void 0 ? void 0 : err.errorCode) !== undefined;
+}
 /** Error codes used to identify different types of errors that can occur while developing apps. */
 var ErrorCode;
 (function (ErrorCode) {
@@ -2428,7 +2433,7 @@ var _minRuntimeConfigToUninitialize = {
  * @hidden
  *  Package version.
  */
-var version = "2.17.1-beta.2";
+var version = "2.18.0-beta.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -8362,6 +8367,11 @@ var meeting;
                 });
             }); };
             registerHandler('meeting.micStateChanged', micStateChangedCallback);
+            var audioDeviceSelectionChangedCallback = function (selectedDevicesInHost) {
+                var _a;
+                (_a = requestAppAudioHandlingParams.audioDeviceSelectionChangedCallback) === null || _a === void 0 ? void 0 : _a.call(requestAppAudioHandlingParams, selectedDevicesInHost);
+            };
+            registerHandler('meeting.audioDeviceSelectionChanged', audioDeviceSelectionChangedCallback);
             callback(isHostAudioless);
         };
         sendMessageToParent('meeting.requestAppAudioHandling', [requestAppAudioHandlingParams.isAppHandlingAudio], callbackInternalRequest);
@@ -8380,6 +8390,9 @@ var meeting;
             if (doesHandlerExist('meeting.micStateChanged')) {
                 removeHandler('meeting.micStateChanged');
             }
+            if (doesHandlerExist('meeting.audioDeviceSelectionChanged')) {
+                removeHandler('meeting.audioDeviceSelectionChanged');
+            }
             callback(isHostAudioless);
         };
         sendMessageToParent('meeting.requestAppAudioHandling', [requestAppAudioHandlingParams.isAppHandlingAudio], callbackInternalStop);
@@ -11985,6 +11998,307 @@ var marketplace;
 
 
 
+
+;// CONCATENATED MODULE: ./src/private/externalAppAuthentication.ts
+
+
+
+
+
+/**
+ * @hidden
+ * Namespace to delegate authentication and message extension requests to the host
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+var externalAppAuthentication;
+(function (externalAppAuthentication) {
+    /**
+     * @hidden
+     * This is the only allowed value for IActionExecuteInvokeRequest.type. Used for validation
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var ActionExecuteInvokeRequestType = 'Action.Execute';
+    /**
+     * @hidden
+     * Used to differentiate between IOriginalRequestInfo types
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var OriginalRequestType;
+    (function (OriginalRequestType) {
+        OriginalRequestType["ActionExecuteInvokeRequest"] = "ActionExecuteInvokeRequest";
+        OriginalRequestType["QueryMessageExtensionRequest"] = "QueryMessageExtensionRequest";
+    })(OriginalRequestType = externalAppAuthentication.OriginalRequestType || (externalAppAuthentication.OriginalRequestType = {}));
+    /**
+     * @hidden
+     * Used to differentiate between IInvokeResponse types
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var InvokeResponseType;
+    (function (InvokeResponseType) {
+        InvokeResponseType["ActionExecuteInvokeResponse"] = "ActionExecuteInvokeResponse";
+        InvokeResponseType["QueryMessageExtensionResponse"] = "QueryMessageExtensionResponse";
+    })(InvokeResponseType = externalAppAuthentication.InvokeResponseType || (externalAppAuthentication.InvokeResponseType = {}));
+    /**
+     * @hidden
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var InvokeErrorCode;
+    (function (InvokeErrorCode) {
+        InvokeErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    })(InvokeErrorCode = externalAppAuthentication.InvokeErrorCode || (externalAppAuthentication.InvokeErrorCode = {}));
+    /*********** END ERROR TYPE ***********/
+    /**
+     * @hidden
+     * @internal
+     * Limited to Microsoft-internal use
+     * TODO - Add more validation here as we get more details on the allowed request schemas
+     */
+    function validateOriginalRequestInfo(originalRequestInfo) {
+        if (originalRequestInfo.requestType === OriginalRequestType.ActionExecuteInvokeRequest) {
+            var actionExecuteRequest = originalRequestInfo;
+            if (actionExecuteRequest.type !== ActionExecuteInvokeRequestType) {
+                var error = {
+                    errorCode: InvokeErrorCode.INTERNAL_ERROR,
+                    message: "Invalid action type ".concat(actionExecuteRequest.type, ". Action type must be \"").concat(ActionExecuteInvokeRequestType, "\""),
+                };
+                throw error;
+            }
+        }
+    }
+    /**
+     * @beta
+     * @hidden
+     * Signals to the host to perform authentication using the given authentication parameters and then resend the request to the application specified by the app ID with the authentication result.
+     * @internal
+     * Limited to Microsoft-internal use
+     * @param appId ID of the application backend to which the request and authentication response should be sent
+     * @param authenticateParameters Parameters for the authentication pop-up
+     * @param originalRequestInfo Information about the original request that should be resent
+     * @returns A promise that resolves to the IInvokeResponse from the application backend and rejects with InvokeError if the host encounters an error while authenticating or resending the request
+     */
+    function authenticateAndResendRequest(appId, authenticateParameters, originalRequestInfo) {
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        validateOriginalRequestInfo(originalRequestInfo);
+        // Ask the parent window to open an authentication window with the parameters provided by the caller.
+        return sendMessageToParentAsync('externalAppAuthentication.authenticateAndResendRequest', [
+            appId,
+            originalRequestInfo,
+            authenticateParameters.url,
+            authenticateParameters.width,
+            authenticateParameters.height,
+            authenticateParameters.isExternal,
+        ]).then(function (_a) {
+            var wasSuccessful = _a[0], response = _a[1];
+            if (wasSuccessful && response.responseType != null) {
+                return response;
+            }
+            else {
+                var error = response;
+                throw error;
+            }
+        });
+    }
+    externalAppAuthentication.authenticateAndResendRequest = authenticateAndResendRequest;
+    /**
+     * @beta
+     * @hidden
+     * Signals to the host to perform SSO authentication for the application specified by the app ID
+     * @internal
+     * Limited to Microsoft-internal use
+     * @param appId ID of the application backend for which the host should attempt SSO authentication
+     * @param authTokenRequest Parameters for SSO authentication
+     * @returns A promise that resolves when authentication and succeeds and rejects with InvokeError on failure
+     */
+    function authenticateWithSSO(appId, authTokenRequest) {
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        return sendMessageToParentAsync('externalAppAuthentication.authenticateWithSSO', [
+            appId,
+            authTokenRequest.resources,
+            authTokenRequest.claims,
+            authTokenRequest.silent,
+        ]).then(function (_a) {
+            var wasSuccessful = _a[0], error = _a[1];
+            if (!wasSuccessful) {
+                throw error;
+            }
+        });
+    }
+    externalAppAuthentication.authenticateWithSSO = authenticateWithSSO;
+    /**
+     * @beta
+     * @hidden
+     * Signals to the host to perform SSO authentication for the application specified by the app ID and then resend the request to the application backend with the authentication result
+     * @internal
+     * Limited to Microsoft-internal use
+     * @param appId ID of the application backend for which the host should attempt SSO authentication and resend the request and authentication response
+     * @param authTokenRequest Parameters for SSO authentication
+     * @param originalRequestInfo Information about the original request that should be resent
+     * @returns A promise that resolves to the IInvokeResponse from the application backend and rejects with InvokeError if the host encounters an error while authenticating or resending the request
+     */
+    function authenticateWithSSOAndResendRequest(appId, authTokenRequest, originalRequestInfo) {
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        validateOriginalRequestInfo(originalRequestInfo);
+        return sendMessageToParentAsync('externalAppAuthentication.authenticateWithSSOAndResendRequest', [appId, originalRequestInfo, authTokenRequest.resources, authTokenRequest.claims, authTokenRequest.silent]).then(function (_a) {
+            var wasSuccessful = _a[0], response = _a[1];
+            if (wasSuccessful && response.responseType != null) {
+                return response;
+            }
+            else {
+                var error = response;
+                throw error;
+            }
+        });
+    }
+    externalAppAuthentication.authenticateWithSSOAndResendRequest = authenticateWithSSOAndResendRequest;
+    /**
+     * @hidden
+     * Checks if the externalAppAuthentication capability is supported by the host
+     * @returns boolean to represent whether externalAppAuthentication capability is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    function isSupported() {
+        return internalAPIs_ensureInitialized(runtime_runtime) && runtime_runtime.supports.externalAppAuthentication ? true : false;
+    }
+    externalAppAuthentication.isSupported = isSupported;
+})(externalAppAuthentication || (externalAppAuthentication = {}));
+
+;// CONCATENATED MODULE: ./src/private/externalAppCardActions.ts
+
+
+
+
+
+/**
+ * @hidden
+ * Namespace to delegate adaptive card action execution to the host
+ * @internal
+ * Limited to Microsoft-internal use
+ */
+var externalAppCardActions;
+(function (externalAppCardActions) {
+    /**
+     * @hidden
+     * The type of deeplink action that was executed by the host
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var ActionOpenUrlType;
+    (function (ActionOpenUrlType) {
+        ActionOpenUrlType["DeepLinkDialog"] = "DeepLinkDialog";
+        ActionOpenUrlType["DeepLinkOther"] = "DeepLinkOther";
+        ActionOpenUrlType["DeepLinkStageView"] = "DeepLinkStageView";
+        ActionOpenUrlType["GenericUrl"] = "GenericUrl";
+    })(ActionOpenUrlType = externalAppCardActions.ActionOpenUrlType || (externalAppCardActions.ActionOpenUrlType = {}));
+    /**
+     * @hidden
+     * Error codes that can be thrown from IExternalAppCardActionService.handleActionOpenUrl
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var ActionOpenUrlErrorCode;
+    (function (ActionOpenUrlErrorCode) {
+        ActionOpenUrlErrorCode["INVALID_LINK"] = "INVALID_LINK";
+        ActionOpenUrlErrorCode["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+        ActionOpenUrlErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    })(ActionOpenUrlErrorCode = externalAppCardActions.ActionOpenUrlErrorCode || (externalAppCardActions.ActionOpenUrlErrorCode = {}));
+    /**
+     * @hidden
+     * Error codes that can be thrown from IExternalAppCardActionService.handleActionSubmit
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    var ActionSubmitErrorCode;
+    (function (ActionSubmitErrorCode) {
+        ActionSubmitErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    })(ActionSubmitErrorCode = externalAppCardActions.ActionSubmitErrorCode || (externalAppCardActions.ActionSubmitErrorCode = {}));
+    /**
+     * @beta
+     * @hidden
+     * Delegates an Adaptive Card Action.Submit request to the host for the application with the provided app ID
+     * @internal
+     * Limited to Microsoft-internal use
+     * @param appId ID of the application the request is intended for
+     * @param actionSubmitPayload The Adaptive Card Action.Submit payload
+     * @param cardActionsConfig The card actions configuration. This indicates which subtypes should be handled by this API
+     * @returns Promise that resolves when the request is completed and rejects with ActionSubmitError if the request fails
+     */
+    function processActionSubmit(appId, actionSubmitPayload, cardActionsConfig) {
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        return sendMessageToParentAsync('externalAppCardActions.processActionSubmit', [
+            appId,
+            actionSubmitPayload,
+            cardActionsConfig,
+        ]).then(function (_a) {
+            var wasSuccessful = _a[0], error = _a[1];
+            if (!wasSuccessful) {
+                throw error;
+            }
+        });
+    }
+    externalAppCardActions.processActionSubmit = processActionSubmit;
+    /**
+     * @beta
+     * @hidden
+     * Delegates an Adaptive Card Action.OpenUrl request to the host for the application with the provided app ID
+     * @internal
+     * Limited to Microsoft-internal use
+     * @param appId ID of the application the request is intended for
+     * @param url The URL to open
+     * @returns Promise that resolves to ActionOpenUrlType indicating the type of URL that was opened on success and rejects with ActionOpenUrlError if the request fails
+     */
+    function processActionOpenUrl(appId, url) {
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        return sendMessageToParentAsync('externalAppCardActions.processActionOpenUrl', [appId, url]).then(function (_a) {
+            var error = _a[0], response = _a[1];
+            if (error) {
+                throw error;
+            }
+            else {
+                return response;
+            }
+        });
+    }
+    externalAppCardActions.processActionOpenUrl = processActionOpenUrl;
+    /**
+     * @hidden
+     * Checks if the externalAppCardActions capability is supported by the host
+     * @returns boolean to represent whether externalAppCardActions capability is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     *
+     * @internal
+     * Limited to Microsoft-internal use
+     */
+    function isSupported() {
+        return internalAPIs_ensureInitialized(runtime_runtime) && runtime_runtime.supports.externalAppCardActions ? true : false;
+    }
+    externalAppCardActions.isSupported = isSupported;
+})(externalAppCardActions || (externalAppCardActions = {}));
 
 ;// CONCATENATED MODULE: ./src/private/files.ts
 
@@ -13519,6 +13833,8 @@ var videoEffectsEx;
 
 
 
+
+
 
 ;// CONCATENATED MODULE: ./src/index.ts