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

package/README.md

@@ -24,7 +24,7 @@ To install the stable [version](https://learn.microsoft.com/javascript/api/overv
 
 ### Production
 
-You can reference these files directly [from here](https://res.cdn.office.net/teams-js/2.8.0/js/MicrosoftTeams.min.js) or point your package manager at them.
+You can reference these files directly [from here](https://res.cdn.office.net/teams-js/2.9.0/js/MicrosoftTeams.min.js) or point your package manager at them.
 
 ## Usage
 
@@ -45,13 +45,13 @@ Reference the library inside of your `.html` page using:
 ```html
 <!-- Microsoft Teams JavaScript API (via CDN) -->
 <script
-  src="https://res.cdn.office.net/teams-js/2.8.0/js/MicrosoftTeams.min.js"
-  integrity="sha384-/DJ9oJEFZSpGiUQx9Na5Yb5svOPPqSb3khKxJ/YgoZ2GtrkzWgSTBpESy3LvMPVk"
+  src="https://res.cdn.office.net/teams-js/2.9.0/js/MicrosoftTeams.min.js"
+  integrity="sha384-wh4L8gn9alg8jFXiHwEw/IgcfK7aT/6Pyby/p5B7zHM+a0Jek5MxzO7AvSlRFvsC"
   crossorigin="anonymous"
 ></script>
 
 <!-- Microsoft Teams JavaScript API (via npm) -->
-<script src="node_modules/@microsoft/teams-js@2.8.0/dist/MicrosoftTeams.min.js"></script>
+<script src="node_modules/@microsoft/teams-js@2.9.0/dist/MicrosoftTeams.min.js"></script>
 
 <!-- Microsoft Teams JavaScript API (via local) -->
 <script src="MicrosoftTeams.min.js"></script>

package/dist/MicrosoftTeams.d.ts

@@ -2075,7 +2075,7 @@ export namespace videoEx {
             * @internal
             * Limited to Microsoft-internal use
             */
-        interface VideoFrame extends video.VideoFrame {
+        interface VideoFrame extends video.VideoFrameData {
                 /**
                     * @hidden
                     * The model output if you passed in an {@linkcode VideoFrameConfig.audioInferenceModel}
@@ -2208,26 +2208,45 @@ export namespace videoEx {
     * This object is used for starting or completing authentication flows.
     */
 export namespace authentication {
+        /**
+            * @hidden
+            * @internal
+            * Limited to Microsoft-internal use; automatically called when library is initialized
+            */
         function initialize(): void;
         /**
             * @deprecated
-            * As of 2.0.0, this function has been deprecated in favor of a Promise-based pattern.
-            * Registers the authentication Communication.handlers
+            * As of 2.0.0, this function has been deprecated in favor of a Promise-based pattern using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}
+            *
+            * Registers handlers to be called with the result of an authentication flow triggered using {@link authentication.authenticate authentication.authenticate(authenticateParameters?: AuthenticateParameters): void}
             *
-            * @param authenticateParameters - A set of values that configure the authentication pop-up.
+            * @param authenticateParameters - Configuration for authentication flow pop-up result communication
             */
         function registerAuthenticationHandlers(authenticateParameters: AuthenticateParameters): void;
         /**
-            * Initiates an authentication request, which opens a new window with the specified settings.
+            * Initiates an authentication flow which requires a new window.
+            * There are two primary uses for this function:
+            * 1. When your app needs to authenticate using a 3rd-party identity provider (not Azure Active Directory)
+            * 2. When your app needs to show authentication UI that is blocked from being shown in an iframe (e.g., Azure Active Directory consent prompts)
+            *
+            * For more details, see [Enable authentication using third-party OAuth provider](https://learn.microsoft.com/microsoftteams/platform/tabs/how-to/authentication/auth-flow-tab)
+            *
+            * This function is *not* needed for "standard" Azure SSO usage. Using {@link getAuthToken} is usually sufficient in that case. For more, see
+            * [Enable SSO for tab apps](https://learn.microsoft.com/microsoftteams/platform/tabs/how-to/authentication/tab-sso-overview))
             *
             * @remarks
             * The authentication flow must start and end from the same domain, otherwise success and failure messages won't be returned to the window that initiated the call.
+            * The [Teams authentication flow](https://learn.microsoft.com/microsoftteams/platform/tabs/how-to/authentication/auth-flow-tab) starts and ends at an endpoint on
+            * your own service (with a redirect round-trip to the 3rd party identity provider in the middle).
             *
-            * @param authenticateParameters - The parameters for the authentication request. It is a required parameter since v2 upgrade
+            * @param authenticateParameters - Parameters describing the authentication window used for executing the authentication flow
             *
-            * @returns Promise that will be fulfilled with the result from the authentication pop-up if successful.
+            * @returns `Promise` that will be fulfilled with the result from the authentication pop-up, if successful. The string in this result is provided in the parameter
+            * passed by your app when it calls {@link notifySuccess} in the pop-up window after returning from the identity provider redirect.
             *
-            * @throws Error if the authentication request fails or is canceled by the user.
+            * @throws `Error` if the authentication request fails or is canceled by the user. This error is provided in the parameter passed by your app when it calls
+            * {@link notifyFailure} in the pop-up window after returning from the identity provider redirect. However, in some cases it can also be provided by
+            * the infrastructure depending on the failure (e.g., a user cancelation)
             *
             */
         function authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise<string>;
@@ -2235,30 +2254,36 @@ export namespace authentication {
             * @deprecated
             * As of 2.0.0, please use {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} instead.
             *
-            * Initiates an authentication request, which opens a new window with the specified settings.
+            * The documentation for {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} applies
+            * to this function.
+            * The one difference is that instead of the result being returned via the `Promise`, the result is returned to the callback functions provided in the
+            * `authenticateParameters` parameter.
             *
-            * @remarks
-            * The authentication flow must start and end from the same domain, otherwise success and failure messages won't be returned to the window that initiated the call.
-            *
-            * @param authenticateParameters - The parameters for the authentication request.
+            * @param authenticateParameters - Parameters describing the authentication window used for executing the authentication flow and callbacks used for indicating the result
             *
             */
         function authenticate(authenticateParameters?: AuthenticateParameters): void;
         /**
-            * Requests an Azure AD token to be issued on behalf of the app. The token is acquired from the cache
-            * if it is not expired. Otherwise a request is sent to Azure AD to obtain a new token.
+            * Requests an Azure AD token to be issued on behalf of your app in an SSO flow.
+            * The token is acquired from the cache if it is not expired. Otherwise a request is sent to Azure AD to
+            * obtain a new token.
+            * This function is used to enable SSO scenarios. See [Enable SSO for tab apps](https://learn.microsoft.com/microsoftteams/platform/tabs/how-to/authentication/tab-sso-overview)
+            * for more details.
             *
             * @param authTokenRequest - An optional set of values that configure the token request.
             *
-            * @returns Promise that will be fulfilled with the token if successful.
+            * @returns `Promise` that will be resolved with the token, if successful.
+            *
+            * @throws `Error` if the request fails in some way
             */
         function getAuthToken(authTokenRequest?: AuthTokenRequestParameters): Promise<string>;
         /**
             * @deprecated
             * As of 2.0.0, please use {@link authentication.getAuthToken authentication.getAuthToken(authTokenRequest: AuthTokenRequestParameters): Promise\<string\>} instead.
             *
-            * Requests an Azure AD token to be issued on behalf of the app. The token is acquired from the cache
-            * if it is not expired. Otherwise a request is sent to Azure AD to obtain a new token.
+            * The documentation {@link authentication.getAuthToken authentication.getAuthToken(authTokenRequest: AuthTokenRequestParameters): Promise\<string\>} applies to this
+            * function as well. The one difference when using this function is that the result is provided in the callbacks in the `authTokenRequest` parameter
+            * instead of as a `Promise`.
             *
             * @param authTokenRequest - An optional set of values that configure the token request.
             * It contains callbacks to call in case of success/failure
@@ -2287,30 +2312,39 @@ export namespace authentication {
             */
         function getUser(userRequest: UserRequest): void;
         /**
-            * Notifies the frame that initiated this authentication request that the request was successful.
+            * When using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}, the
+            * window that was opened to execute the authentication flow should call this method after authentiction to notify the caller of
+            * {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} that the
+            * authentication request was successful.
             *
             * @remarks
-            * This function is usable only on the authentication window.
+            * This function is usable only from the authentication window.
             * This call causes the authentication window to be closed.
             *
-            * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives this value in its callback.
+            * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives
+            * this value in its callback or via the `Promise` return value
             * @param callbackUrl - Specifies the url to redirect back to if the client is Win32 Outlook.
             */
         function notifySuccess(result?: string, callbackUrl?: string): void;
         /**
-            * Notifies the frame that initiated this authentication request that the request failed.
+            * When using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}, the
+            * window that was opened to execute the authentication flow should call this method after authentiction to notify the caller of
+            * {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} that the
+            * authentication request failed.
+    
             *
             * @remarks
             * This function is usable only on the authentication window.
             * This call causes the authentication window to be closed.
             *
-            * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives this value in its callback.
+            * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives
+            * this value in its callback or via the `Promise` return value
             * @param callbackUrl - Specifies the url to redirect back to if the client is Win32 Outlook.
             */
         function notifyFailure(reason?: string, callbackUrl?: string): void;
         /**
             * @deprecated
-            * As of 2.0.0, this interface has been deprecated in favor of a Promise-based pattern.
+            * As of 2.0.0, this interface has been deprecated in favor of leveraging the `Promise` returned from {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}
             *-------------------------
             * Used in {@link AuthenticateParameters} and {@link AuthTokenRequest}
             */
@@ -2318,12 +2352,14 @@ export namespace authentication {
                 /**
                     * @deprecated
                     * As of 2.0.0, this property has been deprecated in favor of a Promise-based pattern.
+                    *
                     * A function that is called if the request succeeds.
                     */
                 successCallback?: (result: string) => void;
                 /**
                     * @deprecated
                     * As of 2.0.0, this property has been deprecated in favor of a Promise-based pattern.
+                    *
                     * A function that is called if the request fails, with the reason for the failure.
                     */
                 failureCallback?: (reason: string) => void;
@@ -2345,13 +2381,22 @@ export namespace authentication {
                     */
                 height?: number;
                 /**
-                    * The flag which indicates whether the auth page should be opened in an external browser. This flag has no effect on the web client.
+                    * Some identity providers restrict their authentication pages from being displayed in embedded browsers (e.g., a web view inside of a native application)
+                    * If the identity provider you are using prevents embedded browser usage, this flag should be set to `true` to enable the authentication page specified in
+                    * the {@link url} property to be opened in an external browser.
+                    * If this flag is `false`, the page will be opened directly within the current hosting application.
+                    *
+                    * This flag is ignored when the host for the application is a web app (as opposed to a native application) as the behavior is unnecessary in a web-only
+                    * environment without an embedded browser.
                     */
                 isExternal?: boolean;
         }
         /**
             * @deprecated
-            * As of 2.0.0, please use {@link AuthenticatePopUpParameters} instead.
+            * As of 2.0.0, please use {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} and
+            * the associated {@link AuthenticatePopUpParameters} instead.
+            *
+            * @see {@link LegacyCallBacks}
             */
         type AuthenticateParameters = AuthenticatePopUpParameters & LegacyCallBacks;
         /**
@@ -2359,7 +2404,9 @@ export namespace authentication {
             */
         interface AuthTokenRequestParameters {
                 /**
-                    * An optional list of resource for which to acquire the access token; only used for full trust apps.
+                    * @hidden
+                    * @internal
+                    * An list of resources for which to acquire the access token; only for internal Microsoft usage
                     */
                 resources?: string[];
                 /**
@@ -6624,7 +6671,7 @@ export namespace video {
             * Represents a video frame
             * @beta
             */
-        interface VideoFrame {
+        interface VideoFrameData {
                 /**
                     * Video frame width
                     */
@@ -6636,7 +6683,7 @@ export namespace video {
                 /**
                     * Video frame buffer
                     */
-                data: Uint8ClampedArray;
+                videoFrameBuffer: Uint8ClampedArray;
                 /**
                     * NV12 luma stride, valid only when video frame format is NV12
                     */
@@ -6659,7 +6706,7 @@ export namespace video {
             * @beta
             */
         enum VideoFrameFormat {
-                NV12 = 0
+                NV12 = "NV12"
         }
         /**
             * Video frame configuration supplied to the host to customize the generated video frame parameters, like format
@@ -6689,7 +6736,7 @@ export namespace video {
             * Video frame call back function definition
             * @beta
             */
-        type VideoFrameCallback = (frame: VideoFrame, notifyVideoFrameProcessed: () => void, notifyError: (errorMessage: string) => void) => void;
+        type VideoFrameCallback = (frame: VideoFrameData, notifyVideoFrameProcessed: () => void, notifyError: (errorMessage: string) => void) => void;
         /**
             * Predefined failure reasons for preparing the selected video effect
             * @beta
@@ -6742,6 +6789,56 @@ export namespace video {
             *
             */
         function isSupported(): boolean;
+        /**
+            * @beta
+            * Namespace to get video frames from a media stream.
+            * When the host supports this capability, developer should call {@link mediaStream.registerForVideoFrame} to get the video frames instead of {@link registerForVideoFrame} to get the video frames, callback of {@link registerForVideoFrame} will be ignored when the host supports this capability.
+            */
+        namespace mediaStream {
+                /**
+                    * @beta
+                    * Checks if video.mediaStream capability is supported by the host
+                    * @returns boolean to represent whether the video.medisStream capability is supported
+                    *
+                    * @throws Error if {@linkcode app.initialize} has not successfully completed
+                    *
+                    */
+                function isSupported(): boolean;
+                /**
+                    * @beta
+                    * Video frame data extracted from the media stream. More properties may be added in the future.
+                    */
+                type MediaStreamFrameData = {
+                        /**
+                            * The video frame from the media stream.
+                            */
+                        videoFrame: VideoFrame;
+                };
+                /**
+                    * @beta
+                    * Video effect change call back function definition.
+                    * The video app should resolve the promise to notify a successfully processed video frame.
+                    * The video app should reject the promise to notify a failure.
+                    */
+                type VideoFrameCallback = (receivedVideoFrame: MediaStreamFrameData) => Promise<VideoFrame>;
+                /**
+                    * @beta
+                    * Register to read the video frames from the media stream provided by the host.
+                    * @param frameCallback - The callback to invoke when recieve a video frame from the media stream.
+                    * @example
+                    * ```typescript
+                    * video.mediaStream.registerForVideoFrame(async (receivedVideoFrame) => {
+                    *  const { videoFrame } = receivedVideoFrame;
+                    *  try {
+                    *    return await processVideoFrame(videoFrame);
+                    *  } catch (error) {
+                    *   throw error;
+                    *  }
+                    * });
+                    * ```
+                    */
+                function registerForVideoFrame(frameCallback: VideoFrameCallback): void;
+        }
 }
 
 /**

package/dist/MicrosoftTeams.js

@@ -2151,7 +2151,7 @@ var _minRuntimeConfigToUninitialize = {
 };
 
 ;// CONCATENATED MODULE: ./src/public/version.ts
-var version = "2.9.0-beta.0";
+var version = "2.9.0";
 
 ;// CONCATENATED MODULE: ./src/internal/internalAPIs.ts
 
@@ -2302,6 +2302,11 @@ var authentication;
 (function (authentication) {
     var authHandlers;
     var authWindowMonitor;
+    /**
+     * @hidden
+     * @internal
+     * Limited to Microsoft-internal use; automatically called when library is initialized
+     */
     function initialize() {
         registerHandler('authentication.authenticate.success', handleSuccess, false);
         registerHandler('authentication.authenticate.failure', handleFailure, false);
@@ -2310,10 +2315,11 @@ var authentication;
     var authParams;
     /**
      * @deprecated
-     * As of 2.0.0, this function has been deprecated in favor of a Promise-based pattern.
-     * Registers the authentication Communication.handlers
+     * As of 2.0.0, this function has been deprecated in favor of a Promise-based pattern using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}
+     *
+     * Registers handlers to be called with the result of an authentication flow triggered using {@link authentication.authenticate authentication.authenticate(authenticateParameters?: AuthenticateParameters): void}
      *
-     * @param authenticateParameters - A set of values that configure the authentication pop-up.
+     * @param authenticateParameters - Configuration for authentication flow pop-up result communication
      */
     function registerAuthenticationHandlers(authenticateParameters) {
         authParams = authenticateParameters;
@@ -2563,13 +2569,17 @@ var authentication;
         });
     }
     /**
-     * Notifies the frame that initiated this authentication request that the request was successful.
+     * When using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}, the
+     * window that was opened to execute the authentication flow should call this method after authentiction to notify the caller of
+     * {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} that the
+     * authentication request was successful.
      *
      * @remarks
-     * This function is usable only on the authentication window.
+     * This function is usable only from the authentication window.
      * This call causes the authentication window to be closed.
      *
-     * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives this value in its callback.
+     * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives
+     * this value in its callback or via the `Promise` return value
      * @param callbackUrl - Specifies the url to redirect back to if the client is Win32 Outlook.
      */
     function notifySuccess(result, callbackUrl) {
@@ -2581,13 +2591,18 @@ var authentication;
     }
     authentication.notifySuccess = notifySuccess;
     /**
-     * Notifies the frame that initiated this authentication request that the request failed.
+     * When using {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>}, the
+     * window that was opened to execute the authentication flow should call this method after authentiction to notify the caller of
+     * {@link authentication.authenticate authentication.authenticate(authenticateParameters: AuthenticatePopUpParameters): Promise\<string\>} that the
+     * authentication request failed.
+  
      *
      * @remarks
      * This function is usable only on the authentication window.
      * This call causes the authentication window to be closed.
      *
-     * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives this value in its callback.
+     * @param result - Specifies a result for the authentication. If specified, the frame that initiated the authentication pop-up receives
+     * this value in its callback or via the `Promise` return value
      * @param callbackUrl - Specifies the url to redirect back to if the client is Win32 Outlook.
      */
     function notifyFailure(reason, callbackUrl) {
@@ -7766,6 +7781,53 @@ var profile;
 })(profile || (profile = {}));
 
 ;// CONCATENATED MODULE: ./src/public/video.ts
+var video_assign = (undefined && undefined.__assign) || function () {
+    video_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return video_assign.apply(this, arguments);
+};
+var video_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());
+    });
+};
+var video_generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 
 
 
@@ -7783,7 +7845,7 @@ var video;
      */
     var VideoFrameFormat;
     (function (VideoFrameFormat) {
-        VideoFrameFormat[VideoFrameFormat["NV12"] = 0] = "NV12";
+        VideoFrameFormat["NV12"] = "NV12";
     })(VideoFrameFormat = video.VideoFrameFormat || (video.VideoFrameFormat = {}));
     /**
      * Video effect change type enum
@@ -7827,10 +7889,14 @@ var video;
         if (!isSupported()) {
             throw errorNotSupportedOnPlatform;
         }
-        registerHandler('video.newVideoFrame', function (videoFrame) {
+        registerHandler('video.newVideoFrame', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function (videoFrame) {
             if (videoFrame) {
-                var timestamp_1 = videoFrame.timestamp;
-                frameCallback(videoFrame, function () {
+                // The host may pass the VideoFrame with the old definition which has `data` instead of `videoFrameBuffer`
+                var videoFrameData = video_assign(video_assign({}, videoFrame), { videoFrameBuffer: videoFrame.videoFrameBuffer || videoFrame.data });
+                var timestamp_1 = videoFrameData.timestamp;
+                frameCallback(videoFrameData, function () {
                     notifyVideoFrameProcessed(timestamp_1);
                 }, notifyError);
             }
@@ -7906,6 +7972,165 @@ var video;
         return ensureInitialized(runtime) && runtime.supports.video ? true : false;
     }
     video.isSupported = isSupported;
+    /**
+     * @beta
+     * Namespace to get video frames from a media stream.
+     * When the host supports this capability, developer should call {@link mediaStream.registerForVideoFrame} to get the video frames instead of {@link registerForVideoFrame} to get the video frames, callback of {@link registerForVideoFrame} will be ignored when the host supports this capability.
+     */
+    var mediaStream;
+    (function (mediaStream_1) {
+        /**
+         * @beta
+         * Checks if video.mediaStream capability is supported by the host
+         * @returns boolean to represent whether the video.medisStream capability is supported
+         *
+         * @throws Error if {@linkcode app.initialize} has not successfully completed
+         *
+         */
+        function isSupported() {
+            var _a;
+            return ensureInitialized(runtime) && isTextureStreamAvailable() && !!((_a = runtime.supports.video) === null || _a === void 0 ? void 0 : _a.mediaStream);
+        }
+        mediaStream_1.isSupported = isSupported;
+        function isTextureStreamAvailable() {
+            var _a, _b, _c, _d;
+            return (typeof window !== 'undefined' &&
+                !!(((_b = (_a = window['chrome']) === null || _a === void 0 ? void 0 : _a.webview) === null || _b === void 0 ? void 0 : _b.getTextureStream) && ((_d = (_c = window['chrome']) === null || _c === void 0 ? void 0 : _c.webview) === null || _d === void 0 ? void 0 : _d.registerTextureStream)));
+        }
+        /**
+         * @beta
+         * Register to read the video frames from the media stream provided by the host.
+         * @param frameCallback - The callback to invoke when recieve a video frame from the media stream.
+         * @example
+         * ```typescript
+         * video.mediaStream.registerForVideoFrame(async (receivedVideoFrame) => {
+         *  const { videoFrame } = receivedVideoFrame;
+         *  try {
+         *    return await processVideoFrame(videoFrame);
+         *  } catch (error) {
+         *   throw error;
+         *  }
+         * });
+         * ```
+         */
+        function registerForVideoFrame(frameCallback) {
+            var _this = this;
+            ensureInitialized(runtime, FrameContexts.sidePanel);
+            if (!isSupported()) {
+                throw errorNotSupportedOnPlatform;
+            }
+            registerHandler('video.startVideoExtensibilityVideoStream', function (mediaStreamInfo) { return video_awaiter(_this, void 0, void 0, function () {
+                var streamId, videoTrack, generator;
+                var _a, _b;
+                return video_generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            streamId = mediaStreamInfo.streamId;
+                            return [4 /*yield*/, getInputVideoTrack(streamId)];
+                        case 1:
+                            videoTrack = _c.sent();
+                            generator = createProcessedStreamGenerator(videoTrack, frameCallback);
+                            // register the video track with processed frames back to the stream:
+                            typeof window !== 'undefined' && ((_b = (_a = window['chrome']) === null || _a === void 0 ? void 0 : _a.webview) === null || _b === void 0 ? void 0 : _b.registerTextureStream(streamId, generator));
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            sendMessageToParent('video.registerForVideoFrame', [
+                {
+                    format: VideoFrameFormat.NV12,
+                },
+            ]);
+        }
+        mediaStream_1.registerForVideoFrame = registerForVideoFrame;
+        /**
+         * Get the video track from the media stream gotten from chrome.webview.getTextureStream(streamId).
+         */
+        function getInputVideoTrack(streamId) {
+            return video_awaiter(this, void 0, void 0, function () {
+                var chrome, mediaStream_2, tracks, error_1, errorMsg;
+                return video_generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (typeof window === 'undefined') {
+                                throw errorNotSupportedOnPlatform;
+                            }
+                            chrome = window['chrome'];
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, chrome.webview.getTextureStream(streamId)];
+                        case 2:
+                            mediaStream_2 = _a.sent();
+                            tracks = mediaStream_2.getVideoTracks();
+                            if (tracks.length === 0) {
+                                throw new Error("No video track in stream ".concat(streamId));
+                            }
+                            return [2 /*return*/, tracks[0]];
+                        case 3:
+                            error_1 = _a.sent();
+                            errorMsg = "Failed to get video track from stream ".concat(streamId, ", error: ").concat(error_1);
+                            notifyError(errorMsg);
+                            throw new Error(errorMsg);
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        /**
+         * The function to create a processed video track from the original video track.
+         * It reads frames from the video track and pipes them to the video frame callback to process the frames.
+         * The processed frames are then enqueued to the generator.
+         * The generator can be registered back to the media stream so that the host can get the processed frames.
+         */
+        function createProcessedStreamGenerator(videoTrack, videoFrameCallback) {
+            var processor = new MediaStreamTrackProcessor({ track: videoTrack });
+            var source = processor.readable;
+            var generator = new MediaStreamTrackGenerator({ kind: 'video' });
+            var sink = generator.writable;
+            source
+                .pipeThrough(new TransformStream({
+                transform: function (originalFrame, controller) {
+                    return video_awaiter(this, void 0, void 0, function () {
+                        var timestamp, frameProcessedByApp, processedFrame, error_2;
+                        return video_generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    timestamp = originalFrame.timestamp;
+                                    if (!(timestamp !== null)) return [3 /*break*/, 5];
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 3, , 4]);
+                                    return [4 /*yield*/, videoFrameCallback({ videoFrame: originalFrame })];
+                                case 2:
+                                    frameProcessedByApp = _a.sent();
+                                    processedFrame = new VideoFrame(frameProcessedByApp, {
+                                        // we need the timestamp to be unchanged from the oirginal frame, so we explicitly set it here.
+                                        timestamp: timestamp,
+                                    });
+                                    controller.enqueue(processedFrame);
+                                    originalFrame.close();
+                                    frameProcessedByApp.close();
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    error_2 = _a.sent();
+                                    originalFrame.close();
+                                    notifyError(error_2);
+                                    return [3 /*break*/, 4];
+                                case 4: return [3 /*break*/, 6];
+                                case 5:
+                                    notifyError('timestamp of the original video frame is null');
+                                    _a.label = 6;
+                                case 6: return [2 /*return*/];
+                            }
+                        });
+                    });
+                },
+            }))
+                .pipeTo(sink);
+            return generator;
+        }
+    })(mediaStream = video.mediaStream || (video.mediaStream = {}));
 })(video || (video = {})); //end of video namespace
 
 ;// CONCATENATED MODULE: ./src/public/search.ts