playkit-sdk 1.2.11 → 1.2.13

package/dist/playkit-sdk.umd.js

@@ -1,5 +1,5 @@
 /**
- * playkit-sdk v1.2.11
+ * playkit-sdk v1.2.13
  * PlayKit SDK for JavaScript
  * @license SEE LICENSE IN LICENSE
  */
@@ -2398,53 +2398,56 @@
 	     *
 	     * @param options - Flow options
 	     * @returns Promise resolving to DeviceAuthResult with tokens
-	     * @throws PlayKitError if a flow is already in progress
 	     */
 	    async startFlow(options = {}) {
-	        // Prevent duplicate flows from running simultaneously
-	        if (DeviceAuthFlowManager.isFlowInProgress) {
-	            this.logger.warn('Device auth flow already in progress, ignoring duplicate call');
-	            throw new PlayKitError('Device auth flow already in progress', 'FLOW_IN_PROGRESS');
-	        }
-	        DeviceAuthFlowManager.isFlowInProgress = true;
+	        // If a flow is already in progress, return the shared promise so all callers get the same result
+	        if (DeviceAuthFlowManager.currentFlowPromise) {
+	            this.logger.debug('Device auth flow already in progress, waiting for existing flow');
+	            return DeviceAuthFlowManager.currentFlowPromise;
+	        }
+	        // Store the flow promise so subsequent calls can await the same result
+	        const flowPromise = this.executeFlow(options);
+	        DeviceAuthFlowManager.currentFlowPromise = flowPromise;
 	        DeviceAuthFlowManager.activeInstance = this;
+	        try {
+	            return await flowPromise;
+	        }
+	        finally {
+	            // Clean up static state when flow completes (success or failure)
+	            DeviceAuthFlowManager.currentFlowPromise = null;
+	            DeviceAuthFlowManager.activeInstance = null;
+	        }
+	    }
+	    /**
+	     * Internal method that executes the actual device auth flow
+	     * @private
+	     */
+	    async executeFlow(options = {}) {
 	        this.aborted = false;
 	        this.currentLanguage = this.detectLanguage();
 	        const scope = options.scope || 'player:play';
 	        const openBrowser = options.openBrowser || this.defaultOpenBrowser.bind(this);
-	        // Helper to reset static flags when flow completes early (before polling)
-	        const resetFlowStateEarly = () => {
-	            DeviceAuthFlowManager.isFlowInProgress = false;
-	            DeviceAuthFlowManager.activeInstance = null;
-	        };
 	        // Generate PKCE parameters (outside try block so codeVerifier is accessible for polling)
 	        const codeVerifier = this.generateCodeVerifier();
 	        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
-	        let initData;
-	        try {
-	            // Step 1: Initiate device auth session
-	            const initResponse = await fetch(`${this.baseURL}/api/device-auth/initiate`, {
-	                method: 'POST',
-	                headers: {
-	                    'Content-Type': 'application/json',
-	                },
-	                body: JSON.stringify({
-	                    game_id: this.gameId,
-	                    code_challenge: codeChallenge,
-	                    code_challenge_method: 'S256',
-	                    scope,
-	                }),
-	            });
-	            if (!initResponse.ok) {
-	                const error = await initResponse.json().catch(() => ({ error_description: 'Failed to initiate device auth' }));
-	                throw new PlayKitError(error.error_description || 'Failed to initiate device auth', error.error || 'INIT_FAILED', initResponse.status);
-	            }
-	            initData = await initResponse.json();
-	        }
-	        catch (err) {
-	            resetFlowStateEarly();
-	            throw err;
+	        // Step 1: Initiate device auth session
+	        const initResponse = await fetch(`${this.baseURL}/api/device-auth/initiate`, {
+	            method: 'POST',
+	            headers: {
+	                'Content-Type': 'application/json',
+	            },
+	            body: JSON.stringify({
+	                game_id: this.gameId,
+	                code_challenge: codeChallenge,
+	                code_challenge_method: 'S256',
+	                scope,
+	            }),
+	        });
+	        if (!initResponse.ok) {
+	            const error = await initResponse.json().catch(() => ({ error_description: 'Failed to initiate device auth' }));
+	            throw new PlayKitError(error.error_description || 'Failed to initiate device auth', error.error || 'INIT_FAILED', initResponse.status);
 	        }
+	        const initData = await initResponse.json();
 	        const { session_id, auth_url, poll_interval, expires_in, game } = initData;
 	        // Update poll interval from server
 	        if (poll_interval) {
@@ -2476,7 +2479,6 @@
 	            }
 	            catch (err) {
 	                this.closeModal();
-	                resetFlowStateEarly();
 	                throw err;
 	            }
 	            // User clicked login - open browser (in user click context, won't be blocked)
@@ -2488,23 +2490,16 @@
 	        }
 	        // Step 3: Poll for authorization
 	        const expiresAt = Date.now() + (expires_in || 600) * 1000;
-	        // Helper to reset static flags when flow completes
-	        const resetFlowState = () => {
-	            DeviceAuthFlowManager.isFlowInProgress = false;
-	            DeviceAuthFlowManager.activeInstance = null;
-	        };
 	        return new Promise((resolve, reject) => {
 	            const poll = async () => {
 	                if (this.aborted) {
 	                    this.closeModal();
-	                    resetFlowState();
 	                    reject(new PlayKitError('Device auth flow was cancelled', 'CANCELLED'));
 	                    return;
 	                }
 	                // Check if session expired
 	                if (Date.now() >= expiresAt) {
 	                    this.showModalError('expired', () => { });
-	                    resetFlowState();
 	                    reject(new PlayKitError('Device auth session expired', 'EXPIRED'));
 	                    return;
 	                }
@@ -2532,7 +2527,6 @@
 	                            }
 	                            this.emit('poll_status', 'authorized');
 	                            this.emit('authenticated', pollData);
-	                            resetFlowState();
 	                            resolve({
 	                                access_token: pollData.access_token,
 	                                token_type: pollData.token_type,
@@ -2561,7 +2555,6 @@
 	                                options.onPollStatus('denied');
 	                            }
 	                            this.emit('poll_status', 'denied');
-	                            resetFlowState();
 	                            reject(new PlayKitError(pollData.error_description || 'User denied authorization', 'ACCESS_DENIED'));
 	                        }
 	                        else if (error === 'expired_token') {
@@ -2570,12 +2563,10 @@
 	                                options.onPollStatus('expired');
 	                            }
 	                            this.emit('poll_status', 'expired');
-	                            resetFlowState();
 	                            reject(new PlayKitError(pollData.error_description || 'Session expired', 'EXPIRED'));
 	                        }
 	                        else {
 	                            this.showModalError('failed', () => { });
-	                            resetFlowState();
 	                            reject(new PlayKitError(pollData.error_description || 'Device auth failed', error || 'POLL_FAILED', pollResponse.status));
 	                        }
 	                    }
@@ -2600,11 +2591,6 @@
 	            clearTimeout(this.pollTimeoutId);
 	            this.pollTimeoutId = null;
 	        }
-	        // Reset static flags if this is the active instance
-	        if (DeviceAuthFlowManager.activeInstance === this) {
-	            DeviceAuthFlowManager.isFlowInProgress = false;
-	            DeviceAuthFlowManager.activeInstance = null;
-	        }
 	        this.emit('cancelled');
 	    }
 	    /**
@@ -2619,7 +2605,7 @@
 	     * Check if a device auth flow is currently in progress (static method)
 	     */
 	    static isInProgress() {
-	        return DeviceAuthFlowManager.isFlowInProgress;
+	        return DeviceAuthFlowManager.currentFlowPromise !== null;
 	    }
 	    /**
 	     * Initiate device auth without opening browser or showing UI.
@@ -2770,8 +2756,8 @@
 	        });
 	    }
 	}
-	/** Static flag to prevent multiple flows running simultaneously */
-	DeviceAuthFlowManager.isFlowInProgress = false;
+	/** Shared promise for the current flow - allows multiple callers to await the same result */
+	DeviceAuthFlowManager.currentFlowPromise = null;
 	/** Reference to the currently active instance */
 	DeviceAuthFlowManager.activeInstance = null;
 
@@ -2789,6 +2775,10 @@
 	        this.authFlowManager = null;
 	        this.deviceAuthFlowManager = null;
 	        this.logger = Logger.getLogger('AuthManager');
+	        /** Shared promise for current device auth flow - allows multiple callers to await the same result */
+	        this.currentDeviceAuthFlowPromise = null;
+	        /** Shared promise for current auth flow (startAuthFlow) - allows multiple callers to await the same result */
+	        this.currentAuthFlowPromise = null;
 	        this.config = config;
 	        // Create TokenStorage with appropriate mode for server vs browser environment
 	        this.storage = new TokenStorage({
@@ -2897,12 +2887,27 @@
 	     * @deprecated 'headless' authentication is deprecated and will be removed in v2.0. Use 'device' instead.
 	     */
 	    async startAuthFlow(authMethod = 'device') {
-	        var _a, _b;
-	        if (this.authFlowManager || this.deviceAuthFlowManager) {
-	            // Already in progress
-	            this.logger.warn('Auth flow already in progress, ignoring duplicate call');
-	            return;
+	        // If a flow is already in progress, return the shared promise so all callers await the same result
+	        if (this.currentAuthFlowPromise) {
+	            this.logger.debug('Auth flow already in progress, waiting for existing flow');
+	            return this.currentAuthFlowPromise;
+	        }
+	        // Store the flow promise so subsequent calls can await the same result
+	        const flowPromise = this.executeAuthFlow(authMethod);
+	        this.currentAuthFlowPromise = flowPromise;
+	        try {
+	            return await flowPromise;
+	        }
+	        finally {
+	            this.currentAuthFlowPromise = null;
 	        }
+	    }
+	    /**
+	     * Internal method that executes the actual auth flow
+	     * @private
+	     */
+	    async executeAuthFlow(authMethod = 'device') {
+	        var _a, _b;
 	        // Deprecation warning for headless auth
 	        if (authMethod === 'headless') {
 	            this.logger.warn('"headless" authentication is deprecated and will be removed in v2.0. ' +
@@ -3155,10 +3160,27 @@
 	     * ```
 	     */
 	    async startDeviceAuthFlow(options = {}) {
-	        var _a;
-	        if (this.deviceAuthFlowManager) {
-	            throw new PlayKitError('Device auth flow already in progress', 'FLOW_IN_PROGRESS');
+	        // If a flow is already in progress, return the shared promise so all callers get the same result
+	        if (this.currentDeviceAuthFlowPromise) {
+	            this.logger.debug('Device auth flow already in progress, waiting for existing flow');
+	            return this.currentDeviceAuthFlowPromise;
+	        }
+	        // Store the flow promise so subsequent calls can await the same result
+	        const flowPromise = this.executeDeviceAuthFlow(options);
+	        this.currentDeviceAuthFlowPromise = flowPromise;
+	        try {
+	            return await flowPromise;
 	        }
+	        finally {
+	            this.currentDeviceAuthFlowPromise = null;
+	        }
+	    }
+	    /**
+	     * Internal method that executes the actual device auth flow
+	     * @private
+	     */
+	    async executeDeviceAuthFlow(options = {}) {
+	        var _a;
 	        try {
 	            this.deviceAuthFlowManager = new DeviceAuthFlowManager(this.baseURL, this.config.gameId);
 	            const result = await this.deviceAuthFlowManager.startFlow(options);
@@ -3211,8 +3233,10 @@
 	     * ```
 	     */
 	    async initiateDeviceAuth(scope = 'player:play') {
+	        // If there's an existing manager, clean it up first (allows restarting flow)
 	        if (this.deviceAuthFlowManager) {
-	            throw new PlayKitError('Device auth already in progress', 'FLOW_IN_PROGRESS');
+	            this.logger.debug('Cleaning up existing device auth manager before initiating new flow');
+	            this.deviceAuthFlowManager.destroy();
 	        }
 	        this.deviceAuthFlowManager = new DeviceAuthFlowManager(this.baseURL, this.config.gameId);
 	        return this.deviceAuthFlowManager.initiateAuth(scope);