playkit-sdk 1.2.11 → 1.2.13

package/dist/playkit-sdk.d.ts

@@ -927,8 +927,8 @@ interface DeviceAuthInitResult {
     game?: GameInfo;
 }
 declare class DeviceAuthFlowManager extends EventEmitter {
-    /** Static flag to prevent multiple flows running simultaneously */
-    private static isFlowInProgress;
+    /** Shared promise for the current flow - allows multiple callers to await the same result */
+    private static currentFlowPromise;
     /** Reference to the currently active instance */
     private static activeInstance;
     private baseURL;
@@ -985,9 +985,13 @@ declare class DeviceAuthFlowManager extends EventEmitter {
      *
      * @param options - Flow options
      * @returns Promise resolving to DeviceAuthResult with tokens
-     * @throws PlayKitError if a flow is already in progress
      */
     startFlow(options?: DeviceAuthFlowOptions): Promise<DeviceAuthResult>;
+    /**
+     * Internal method that executes the actual device auth flow
+     * @private
+     */
+    private executeFlow;
     /**
      * Cancel the ongoing device auth flow
      */
@@ -1063,6 +1067,10 @@ declare class AuthManager extends EventEmitter {
     private authFlowManager;
     private deviceAuthFlowManager;
     private logger;
+    /** Shared promise for current device auth flow - allows multiple callers to await the same result */
+    private currentDeviceAuthFlowPromise;
+    /** Shared promise for current auth flow (startAuthFlow) - allows multiple callers to await the same result */
+    private currentAuthFlowPromise;
     constructor(config: SDKConfig);
     /**
      * Initialize authentication
@@ -1075,6 +1083,11 @@ declare class AuthManager extends EventEmitter {
      * @deprecated 'headless' authentication is deprecated and will be removed in v2.0. Use 'device' instead.
      */
     startAuthFlow(authMethod?: 'device' | 'headless'): Promise<void>;
+    /**
+     * Internal method that executes the actual auth flow
+     * @private
+     */
+    private executeAuthFlow;
     /**
      * Exchange JWT for player token
      */
@@ -1153,6 +1166,11 @@ declare class AuthManager extends EventEmitter {
      * ```
      */
     startDeviceAuthFlow(options?: DeviceAuthFlowOptions): Promise<DeviceAuthResult>;
+    /**
+     * Internal method that executes the actual device auth flow
+     * @private
+     */
+    private executeDeviceAuthFlow;
     /**
      * Cancel ongoing device auth flow
      */

package/dist/playkit-sdk.esm.js

@@ -1,5 +1,5 @@
 /**
- * playkit-sdk v1.2.11
+ * playkit-sdk v1.2.13
  * PlayKit SDK for JavaScript
  * @license SEE LICENSE IN LICENSE
  */
@@ -2047,53 +2047,56 @@ class DeviceAuthFlowManager extends EventEmitter {
      *
      * @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) {
@@ -2125,7 +2128,6 @@ class DeviceAuthFlowManager extends EventEmitter {
             }
             catch (err) {
                 this.closeModal();
-                resetFlowStateEarly();
                 throw err;
             }
             // User clicked login - open browser (in user click context, won't be blocked)
@@ -2137,23 +2139,16 @@ class DeviceAuthFlowManager extends EventEmitter {
         }
         // 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;
                 }
@@ -2181,7 +2176,6 @@ class DeviceAuthFlowManager extends EventEmitter {
                             }
                             this.emit('poll_status', 'authorized');
                             this.emit('authenticated', pollData);
-                            resetFlowState();
                             resolve({
                                 access_token: pollData.access_token,
                                 token_type: pollData.token_type,
@@ -2210,7 +2204,6 @@ class DeviceAuthFlowManager extends EventEmitter {
                                 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') {
@@ -2219,12 +2212,10 @@ class DeviceAuthFlowManager extends EventEmitter {
                                 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));
                         }
                     }
@@ -2249,11 +2240,6 @@ class DeviceAuthFlowManager extends EventEmitter {
             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');
     }
     /**
@@ -2268,7 +2254,7 @@ class DeviceAuthFlowManager extends EventEmitter {
      * 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.
@@ -2419,8 +2405,8 @@ class DeviceAuthFlowManager extends EventEmitter {
         });
     }
 }
-/** 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;
 
@@ -2438,6 +2424,10 @@ class AuthManager extends EventEmitter {
         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({
@@ -2546,12 +2536,27 @@ class AuthManager extends EventEmitter {
      * @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. ' +
@@ -2804,10 +2809,27 @@ class AuthManager extends EventEmitter {
      * ```
      */
     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);
@@ -2860,8 +2882,10 @@ class AuthManager extends EventEmitter {
      * ```
      */
     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);