@microsoft/teams-js 2.18.0 → 2.19.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),
@@ -887,6 +889,7 @@ __webpack_require__.d(__webpack_exports__, {
   tasks: () => (/* reexport */ tasks),
   teams: () => (/* reexport */ teams),
   teamsCore: () => (/* reexport */ teamsCore),
+  thirdPartyCloudStorage: () => (/* reexport */ thirdPartyCloudStorage),
   uploadCustomApp: () => (/* reexport */ uploadCustomApp),
   version: () => (/* reexport */ version),
   videoEffects: () => (/* reexport */ videoEffects),
@@ -2431,7 +2434,7 @@ var _minRuntimeConfigToUninitialize = {
  * @hidden
  *  Package version.
  */
-var version = "2.18.0";
+var version = "2.19.0-beta.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -8424,6 +8427,13 @@ var meeting;
 
 
 
+/**
+ * @hidden
+ * Hidden from Docs
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
 var monetization;
 (function (monetization) {
     /**
@@ -8756,6 +8766,9 @@ var teamsCore;
 
 
 
+/**
+ * Allows your app to add a people picker enabling users to search for and select people in their organization.
+ */
 var people;
 (function (people_1) {
     /**
@@ -10697,6 +10710,149 @@ var appInitialization;
     appInitialization.notifyExpectedFailure = notifyExpectedFailure;
 })(appInitialization || (appInitialization = {}));
 
+;// CONCATENATED MODULE: ./src/public/thirdPartyCloudStorage.ts
+
+
+
+
+
+
+
+var Files3PLogger = getLogger('thirdPartyCloudStorage');
+/**
+ * Extended files API 3P storage providers, features like sending Blob from Teams to 3P app on user
+ * actions like drag and drop to compose
+ * @beta
+ */
+var thirdPartyCloudStorage;
+(function (thirdPartyCloudStorage) {
+    /** Get context callback function type */
+    var files = [];
+    var helper = {
+        fileType: '',
+        assembleAttachment: [],
+    };
+    var lastChunkVal = true; // setting it to true so that the very first file and first chunk does not fail
+    var callback = null;
+    /**
+     * Get drag-and-drop files using a callback.
+     *
+     * @param {string} dragAndDropInput - Teams thread id or Teams conversation id from a Teams chat/channel
+     * @param {DragAndDropFileCallback} dragAndDropFileCallback - callback
+     *   A callback function to handle the result of the operation
+     * @beta
+     */
+    function getDragAndDropFiles(dragAndDropInput, dragAndDropFileCallback) {
+        if (!dragAndDropFileCallback) {
+            throw new Error('[getDragAndDropFiles] Callback cannot be null');
+        }
+        if (!dragAndDropInput || dragAndDropInput === '') {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            dragAndDropFileCallback([], invalidInput);
+            return;
+        }
+        internalAPIs_ensureInitialized(runtime_runtime, FrameContexts.content, FrameContexts.task);
+        if (!isSupported()) {
+            throw errorNotSupportedOnPlatform;
+        }
+        if (callback) {
+            callback = null;
+            throw new Error('getDragAndDropFiles cannot be called twice');
+        }
+        else {
+            callback = dragAndDropFileCallback;
+        }
+        lastChunkVal = true;
+        sendMessageToParent('thirdPartyCloudStorage.getDragAndDropFiles', [dragAndDropInput], handleGetDragAndDropFilesCallbackRequest);
+    }
+    thirdPartyCloudStorage.getDragAndDropFiles = getDragAndDropFiles;
+    function handleGetDragAndDropFilesCallbackRequest(fileResult) {
+        if (callback) {
+            if (fileResult && fileResult.error) {
+                callback([], fileResult.error);
+                callback = null;
+            }
+            else {
+                if (fileResult && fileResult.fileChunk) {
+                    try {
+                        if (!lastChunkVal && fileResult.fileChunk.chunkSequence === 0) {
+                            // last chunk value was false
+                            Files3PLogger("Last chunk is not received or 'endOfFile' value for previous chunk was not set to true");
+                            lastChunkVal = true; // for next iteration
+                            callback([], {
+                                errorCode: ErrorCode.INTERNAL_ERROR,
+                                message: 'error occurred while receiving data',
+                            });
+                            files = [];
+                            callback = null;
+                        }
+                        var assemble = decodeAttachment(fileResult.fileChunk, fileResult.fileType);
+                        if (assemble) {
+                            helper.assembleAttachment.push(assemble);
+                        }
+                        else {
+                            Files3PLogger("Received a null assemble attachment for when decoding chunk sequence ".concat(fileResult.fileChunk.chunkSequence, "; not including the chunk in the assembled file."));
+                            callback
+                                ? callback([], { errorCode: ErrorCode.INTERNAL_ERROR, message: 'error occurred while receiving data' })
+                                : (callback = null);
+                            files = [];
+                            callback = null;
+                            lastChunkVal = true;
+                        }
+                        // we will store this value to determine whether we received the last chunk of the previous file
+                        lastChunkVal = fileResult.fileChunk.endOfFile;
+                        if (fileResult.fileChunk.endOfFile) {
+                            var fileBlob = createFile(helper.assembleAttachment, helper.fileType);
+                            if (fileBlob) {
+                                // Convert blob to File
+                                var receivedFile = new File([fileBlob], fileResult.fileName, {
+                                    type: fileBlob.type,
+                                });
+                                files.push(receivedFile);
+                            }
+                            if (fileResult.isLastFile && callback) {
+                                callback(files, fileResult.error);
+                                files = [];
+                                callback = null;
+                                lastChunkVal = true;
+                            }
+                            helper = {
+                                fileType: '',
+                                assembleAttachment: [],
+                            };
+                        }
+                    }
+                    catch (e) {
+                        if (callback) {
+                            callback([], { errorCode: ErrorCode.INTERNAL_ERROR, message: e });
+                            files = [];
+                            callback = null;
+                            lastChunkVal = true;
+                        }
+                    }
+                }
+                else {
+                    callback([], { errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' });
+                    files = [];
+                    callback = null;
+                    lastChunkVal = true;
+                }
+            }
+        }
+    }
+    /**
+     * Checks if the thirdPartyCloudStorage capability is supported by the host
+     * @returns boolean to represent whether the thirdPartyCloudStorage capability is supported
+     *
+     * @throws Error if {@linkcode app.initialize} has not successfully completed
+     * @beta
+     */
+    function isSupported() {
+        return internalAPIs_ensureInitialized(runtime_runtime) && runtime_runtime.supports.thirdPartyCloudStorage ? true : false;
+    }
+    thirdPartyCloudStorage.isSupported = isSupported;
+})(thirdPartyCloudStorage || (thirdPartyCloudStorage = {}));
+
 ;// CONCATENATED MODULE: ./src/public/publicAPIs.ts
 
 
@@ -11994,8 +12150,309 @@ 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. This must be a UUID
+     * @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.href,
+            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. This must be a UUID
+     * @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.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. This must be a UUID.
+     * @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.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["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+        ActionOpenUrlErrorCode["INVALID_LINK"] = "INVALID_LINK";
+        ActionOpenUrlErrorCode["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    })(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. This must be a UUID
+     * @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. This must be a UUID
+     * @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.href]).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
 
@@ -12671,6 +13128,13 @@ var meetingRoom;
 
 
 
+/**
+ * @hidden
+ * Hidden from Docs
+ *
+ * @internal
+ * Limited to Microsoft-internal use
+ */
 var notifications;
 (function (notifications) {
     /**
@@ -13530,6 +13994,8 @@ var videoEffectsEx;
 
 
 
+
+
 
 ;// CONCATENATED MODULE: ./src/index.ts