win-portal-auth-sdk 1.2.1 → 1.3.1

package/dist/client/auth-client.js

@@ -13,16 +13,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const api_1 = require("./api");
+const token_utils_1 = require("../utils/token-utils");
+const logger_1 = require("../utils/logger");
+// Constants - Default values
+const DEFAULT_INACTIVITY_TIMEOUT_SECONDS = 30 * 60; // 30 minutes
+const DEFAULT_WARNING_SECONDS = 5 * 60; // 5 minutes
+const DEFAULT_SESSION_CHECK_INTERVAL_SECONDS = 30; // 30 seconds
+// Internal constants - Rate limiting (ไม่ควรให้ customize)
+const REFRESH_COOLDOWN_MS = 30 * 1000; // 30 seconds - rate limiting for refresh
+const WARNING_COOLDOWN_MS = 60 * 1000; // 1 minute - rate limiting for warnings
+// Internal constants - Performance tuning (สามารถ customize ได้ผ่าน advanced config)
+const DEFAULT_ACTIVITY_THROTTLE_MS = 1000; // 1 second - throttle activity handler
+const DEFAULT_REFRESH_TIMEOUT_MS = 5000; // 5 seconds - refresh timeout
 class AuthClient {
     constructor(config) {
         this.token = null;
         this.authType = 'hybrid'; // Default to hybrid
+        // Automatic refresh configuration
+        this.refreshTokenCallbacks = null;
+        this.jwtConfigPromise = null;
+        this.refreshThresholdMinutes = null;
+        this.automaticRefreshEnabled = null;
+        this.lastRefreshAttempt = 0;
+        this.refreshPromise = null;
+        // Session expiration monitoring
+        this.sessionExpirationCallbacks = null;
+        this.sessionManagementConfig = null;
+        this.sessionManagementConfigPromise = null;
+        this.sessionExpirationCheckInterval = null;
+        this.sessionExpirationCheckIntervalSeconds = DEFAULT_SESSION_CHECK_INTERVAL_SECONDS;
+        this.lastWarningTime = 0;
+        // Inactivity detection
+        this.inactivityCallbacks = null;
+        this.inactivityTimeout = null;
+        this.inactivityWarningTimeout = null;
+        this.lastActivityTime = 0;
+        this.inactivityDetectionEnabled = false;
+        this.inactivityTimeoutSeconds = 0;
+        this.inactivityWarningSeconds = 0;
+        this.activityEvents = [];
+        this.activityHandler = null;
+        this.activityThrottleTimeout = null;
+        this.activityThrottleMs = DEFAULT_ACTIVITY_THROTTLE_MS;
+        this.refreshTimeoutMs = DEFAULT_REFRESH_TIMEOUT_MS;
         this.apiKey = config.apiKey;
         this.apiKeyHeader = config.apiKeyHeader || 'X-API-Key';
-        console.log('[AuthClient] Initializing with config:', {
+        // Apply advanced config if provided
+        if (config.advanced) {
+            this.activityThrottleMs = config.advanced.activityThrottleMs ?? DEFAULT_ACTIVITY_THROTTLE_MS;
+            this.refreshTimeoutMs = config.advanced.refreshTimeoutMs ?? DEFAULT_REFRESH_TIMEOUT_MS;
+        }
+        logger_1.logger.debug('Initializing with config:', {
             baseURL: config.baseURL,
             timeout: config.timeout,
             apiKeyHeader: this.apiKeyHeader,
+            advanced: config.advanced,
         });
         this.client = axios_1.default.create({
             baseURL: config.baseURL,
@@ -31,8 +76,8 @@ class AuthClient {
                 'Content-Type': 'application/json',
             },
         });
-        // Add request interceptor to inject API key
-        this.client.interceptors.request.use((requestConfig) => {
+        // Add request interceptor to inject API key and handle automatic refresh
+        this.client.interceptors.request.use(async (requestConfig) => {
             if (requestConfig.headers) {
                 requestConfig.headers[this.apiKeyHeader] = this.apiKey;
                 // Inject JWT token if available
@@ -40,19 +85,93 @@ class AuthClient {
                     requestConfig.headers['Authorization'] = `Bearer ${this.token}`;
                     // ✅ Inject X-Auth-Type header for better performance
                     requestConfig.headers['X-Auth-Type'] = this.authType;
+                    // ✅ Automatic token refresh: ตรวจสอบและ refresh token ก่อนหมดอายุ
+                    if (this.refreshTokenCallbacks &&
+                        (0, token_utils_1.isTokenValid)(this.token) &&
+                        this.refreshThresholdMinutes !== null &&
+                        this.automaticRefreshEnabled === true) {
+                        if ((0, token_utils_1.isTokenNearExpiration)(this.token, this.refreshThresholdMinutes)) {
+                            const remainingMinutes = (0, token_utils_1.getTokenExpirationMinutes)(this.token);
+                            const isCritical = remainingMinutes !== null && remainingMinutes <= 1;
+                            const now = Date.now();
+                            const timeSinceLastRefresh = now - this.lastRefreshAttempt;
+                            if (timeSinceLastRefresh >= REFRESH_COOLDOWN_MS && !this.refreshPromise) {
+                                logger_1.logger.debug(`Token near expiration (${remainingMinutes} min remaining), refreshing...`);
+                                this.lastRefreshAttempt = now;
+                                if (isCritical) {
+                                    // Critical: await refresh
+                                    try {
+                                        const newToken = await Promise.race([
+                                            this.performRefresh(),
+                                            new Promise((_, reject) => setTimeout(() => reject(new Error('Refresh timeout')), this.refreshTimeoutMs)),
+                                        ]);
+                                        this.token = newToken;
+                                        requestConfig.headers['Authorization'] = `Bearer ${newToken}`;
+                                        logger_1.logger.info('Token refreshed successfully (critical)');
+                                    }
+                                    catch (error) {
+                                        logger_1.logger.error('Critical token refresh failed:', error);
+                                    }
+                                }
+                                else {
+                                    // Background refresh
+                                    this.performRefresh().catch((error) => {
+                                        logger_1.logger.error('Background token refresh failed:', error);
+                                    });
+                                }
+                            }
+                        }
+                    }
                 }
             }
             return requestConfig;
         }, (error) => {
             return Promise.reject(error);
         });
-        // Add response interceptor for error handling
-        this.client.interceptors.response.use((response) => response, (error) => {
+        // Add response interceptor for error handling and token refresh on 401
+        this.client.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            // Handle 401 errors - try refresh token before failing
+            if (error.response?.status === 401 && originalRequest && this.refreshTokenCallbacks) {
+                if (originalRequest._retry) {
+                    logger_1.logger.warn('401 Unauthorized after retry - refresh failed');
+                    if (this.refreshTokenCallbacks.onRefreshFailure) {
+                        await this.refreshTokenCallbacks.onRefreshFailure();
+                    }
+                    return Promise.reject(error);
+                }
+                // Skip refresh for refresh endpoint itself
+                if (originalRequest.url?.includes('/auth/refresh') || originalRequest.url?.includes('/auth/refresh-token')) {
+                    logger_1.logger.error('Refresh endpoint failed - session expired');
+                    if (this.refreshTokenCallbacks.onRefreshFailure) {
+                        await this.refreshTokenCallbacks.onRefreshFailure();
+                    }
+                    return Promise.reject(error);
+                }
+                // Try to refresh token
+                try {
+                    originalRequest._retry = true;
+                    logger_1.logger.debug('401 detected, attempting token refresh...');
+                    const newToken = await this.performRefresh();
+                    originalRequest.headers = originalRequest.headers || {};
+                    originalRequest.headers.Authorization = `Bearer ${newToken}`;
+                    logger_1.logger.debug('Token refreshed, retrying original request...');
+                    return this.client(originalRequest);
+                }
+                catch (refreshError) {
+                    logger_1.logger.error('Token refresh failed:', refreshError);
+                    if (this.refreshTokenCallbacks.onRefreshFailure) {
+                        await this.refreshTokenCallbacks.onRefreshFailure();
+                    }
+                    return Promise.reject(refreshError);
+                }
+            }
+            // Handle other errors
             if (error.response?.status === 401) {
-                console.error('[AuthClient] API Key authentication failed');
+                logger_1.logger.error('API Key authentication failed');
             }
             else if (error.response?.status === 429) {
-                console.error('[AuthClient] Rate limit exceeded');
+                logger_1.logger.error('Rate limit exceeded');
             }
             return Promise.reject(error);
         });
@@ -62,6 +181,7 @@ class AuthClient {
         this.systemConfig = new api_1.SystemConfigAPI(this);
         this.files = new api_1.FilesAPI(this);
         this.eventLog = new api_1.EventLogApi(this);
+        this.license = new api_1.LicenseAPI(this);
         this.line = new api_1.LineAPI(this);
     }
     /**
@@ -77,7 +197,7 @@ class AuthClient {
      * ```
      */
     initializeOAuth(config) {
-        console.log('[AuthClient] Initializing OAuth with:', {
+        logger_1.logger.debug('Initializing OAuth with:', {
             clientId: config.clientId,
             redirectUri: config.redirectUri,
             scope: config.scope,
@@ -151,7 +271,13 @@ class AuthClient {
     setToken(token, type = 'jwt') {
         this.token = token;
         this.authType = type;
-        console.log(`[AuthClient] Token set with type: ${type}`);
+        logger_1.logger.debug(`Token set with type: ${type}`);
+        // Reset warning time when token changes
+        this.lastWarningTime = 0;
+        // If session expiration monitoring is enabled, check immediately
+        if (this.sessionExpirationCallbacks) {
+            this.checkSessionExpiration();
+        }
     }
     /**
      * Get current token type
@@ -166,7 +292,7 @@ class AuthClient {
      */
     setAuthType(type) {
         this.authType = type;
-        console.log(`[AuthClient] Auth type changed to: ${type}`);
+        logger_1.logger.debug(`Auth type changed to: ${type}`);
     }
     /**
      * Get current token (masked)
@@ -185,6 +311,7 @@ class AuthClient {
     clearToken() {
         this.token = null;
         this.authType = 'hybrid';
+        this.lastWarningTime = 0;
     }
     /**
      * Get axios instance for advanced usage
@@ -192,5 +319,573 @@ class AuthClient {
     getAxiosInstance() {
         return this.client;
     }
+    /**
+     * Enable automatic token refresh
+     * Call this after user is authenticated to enable automatic refresh
+     *
+     * @param options - Options for automatic refresh
+     *
+     * @example
+     * ```typescript
+     * // Simple: SDK manages localStorage automatically
+     * await authClient.enableAutomaticRefresh({
+     *   refreshTokenKey: 'refresh_token',
+     *   onRefreshFailure: () => window.location.href = '/login'
+     * });
+     *
+     * // Advanced: Custom callbacks
+     * await authClient.enableAutomaticRefresh({
+     *   callbacks: {
+     *     getRefreshToken: () => customStorage.get('refresh_token'),
+     *     setRefreshToken: (token) => customStorage.set('refresh_token', token),
+     *     clearRefreshToken: () => customStorage.remove('refresh_token'),
+     *     onRefreshFailure: () => window.location.href = '/login'
+     *   }
+     * });
+     * ```
+     */
+    async enableAutomaticRefresh(options) {
+        if (options.refreshTokenKey) {
+            // Use localStorage with provided key
+            const key = options.refreshTokenKey;
+            this.refreshTokenCallbacks = {
+                getRefreshToken: () => {
+                    if (typeof window === 'undefined')
+                        return null;
+                    return localStorage.getItem(key);
+                },
+                setRefreshToken: (token) => {
+                    if (typeof window === 'undefined')
+                        return;
+                    localStorage.setItem(key, token);
+                },
+                clearRefreshToken: () => {
+                    if (typeof window === 'undefined')
+                        return;
+                    localStorage.removeItem(key);
+                },
+                onRefreshFailure: options.onRefreshFailure,
+            };
+        }
+        else if (options.callbacks) {
+            // Use custom callbacks
+            this.refreshTokenCallbacks = {
+                ...options.callbacks,
+                onRefreshFailure: options.onRefreshFailure || options.callbacks.onRefreshFailure,
+            };
+        }
+        else {
+            throw new Error('Either refreshTokenKey or callbacks must be provided');
+        }
+        await this.loadJwtConfig();
+    }
+    /**
+     * Disable automatic token refresh
+     */
+    disableAutomaticRefresh() {
+        this.refreshTokenCallbacks = null;
+        this.refreshThresholdMinutes = null;
+        this.automaticRefreshEnabled = null;
+        this.jwtConfigPromise = null;
+    }
+    /**
+     * Load JWT config from API
+     */
+    async loadJwtConfig() {
+        if (this.jwtConfigPromise) {
+            return this.jwtConfigPromise;
+        }
+        this.jwtConfigPromise = this.performJwtConfigLoad();
+        return this.jwtConfigPromise;
+    }
+    /**
+     * Perform JWT config load
+     */
+    async performJwtConfigLoad() {
+        try {
+            const config = await this.systemConfig.getSecurityJwtConfig();
+            this.refreshThresholdMinutes = config.refresh_threshold_minutes;
+            this.automaticRefreshEnabled = config.automatic_refresh ?? true;
+            logger_1.logger.debug(`JWT config loaded: refresh_threshold_minutes=${this.refreshThresholdMinutes} minutes, automatic_refresh=${this.automaticRefreshEnabled}`);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to load JWT config:', error);
+            // Reset to allow retry
+            this.jwtConfigPromise = null;
+            throw error;
+        }
+    }
+    /**
+     * Perform token refresh
+     */
+    async performRefresh() {
+        // If refresh is already in progress, wait for it
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        if (!this.refreshTokenCallbacks) {
+            throw new Error('Refresh token callbacks not configured');
+        }
+        this.refreshPromise = this.doRefresh();
+        try {
+            const newToken = await this.refreshPromise;
+            return newToken;
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+    }
+    /**
+     * Execute refresh token request
+     */
+    async doRefresh() {
+        if (!this.refreshTokenCallbacks) {
+            throw new Error('Refresh token callbacks not configured');
+        }
+        const refreshToken = await this.refreshTokenCallbacks.getRefreshToken();
+        if (!refreshToken) {
+            throw new Error('No refresh token available');
+        }
+        try {
+            // Try refreshWithToken first (for mobile apps with refresh token)
+            const session = await this.auth.refreshWithToken(refreshToken);
+            const newAccessToken = session.access_token;
+            // Update token in client
+            this.token = newAccessToken;
+            // Save new refresh token if rotated
+            if (session.refresh_token) {
+                await this.refreshTokenCallbacks.setRefreshToken(session.refresh_token);
+            }
+            logger_1.logger.debug('Token refreshed successfully');
+            return newAccessToken;
+        }
+        catch (error) {
+            // If refreshWithToken fails, try regular refresh endpoint
+            if (error.response?.status === 404 || error.response?.status === 400) {
+                try {
+                    const tokens = await this.auth.refresh(refreshToken);
+                    const newAccessToken = tokens.access_token;
+                    this.token = newAccessToken;
+                    if (tokens.refresh_token) {
+                        await this.refreshTokenCallbacks.setRefreshToken(tokens.refresh_token);
+                    }
+                    logger_1.logger.debug('Token refreshed successfully (fallback)');
+                    return newAccessToken;
+                }
+                catch (fallbackError) {
+                    logger_1.logger.error('Fallback refresh also failed:', fallbackError);
+                    throw fallbackError;
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Reload JWT config (for when config changes)
+     */
+    async reloadJwtConfig() {
+        this.jwtConfigPromise = null;
+        this.refreshThresholdMinutes = null;
+        this.automaticRefreshEnabled = null;
+        await this.loadJwtConfig();
+    }
+    /**
+     * Enable session expiration monitoring
+     * จะตรวจสอบ session expiration ตาม config จาก settings/sessions และเรียก callback เมื่อใกล้หมดอายุ
+     *
+     * @param options - Options for session expiration monitoring
+     *
+     * @example
+     * ```typescript
+     * await authClient.enableSessionExpirationMonitoring({
+     *   callbacks: {
+     *     onSessionExpiring: (remainingMinutes, expirationType) => {
+     *       console.log(`Session will expire in ${remainingMinutes} minutes (${expirationType})`);
+     *       // แสดง notification หรือ dialog
+     *     },
+     *     onSessionExpired: () => {
+     *       console.log('Session expired');
+     *       // Redirect to login
+     *     }
+     *   },
+     *   checkIntervalSeconds: 30 // ตรวจสอบทุก 30 วินาที
+     * });
+     * ```
+     */
+    async enableSessionExpirationMonitoring(options) {
+        this.sessionExpirationCallbacks = options.callbacks;
+        this.sessionExpirationCheckIntervalSeconds = options.checkIntervalSeconds ?? DEFAULT_SESSION_CHECK_INTERVAL_SECONDS;
+        // Load session management config
+        await this.loadSessionManagementConfig();
+        // Start monitoring
+        this.startSessionExpirationMonitoring();
+    }
+    /**
+     * Disable session expiration monitoring
+     */
+    disableSessionExpirationMonitoring() {
+        this.stopSessionExpirationMonitoring();
+        this.sessionExpirationCallbacks = null;
+        this.sessionManagementConfig = null;
+        this.sessionManagementConfigPromise = null;
+    }
+    /**
+     * Load session management config from API
+     */
+    async loadSessionManagementConfig() {
+        if (this.sessionManagementConfigPromise) {
+            return this.sessionManagementConfigPromise;
+        }
+        this.sessionManagementConfigPromise = this.performSessionManagementConfigLoad();
+        return this.sessionManagementConfigPromise;
+    }
+    /**
+     * Perform session management config load
+     */
+    async performSessionManagementConfigLoad() {
+        try {
+            const config = await this.systemConfig.getSessionManagement();
+            this.sessionManagementConfig = config;
+            logger_1.logger.debug('Session management config loaded:', {
+                inactivityEnabled: config.inactivity.enabled,
+                inactivityTimeout: `${config.inactivity.timeout_duration} ${config.inactivity.timeout_unit}`,
+                inactivityWarningMinutes: config.inactivity.warning_minutes,
+                lifetimeEnabled: config.lifetime.enabled,
+                lifetimeMax: config.lifetime.enabled ? `${config.lifetime.max_duration} ${config.lifetime.max_unit}` : 'N/A',
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to load session management config:', error);
+            // Reset to allow retry
+            this.sessionManagementConfigPromise = null;
+            throw error;
+        }
+    }
+    /**
+     * Start session expiration monitoring interval
+     */
+    startSessionExpirationMonitoring() {
+        // Clear existing interval if any
+        this.stopSessionExpirationMonitoring();
+        // Check immediately
+        this.checkSessionExpiration();
+        // Set up interval
+        this.sessionExpirationCheckInterval = setInterval(() => {
+            this.checkSessionExpiration();
+        }, this.sessionExpirationCheckIntervalSeconds * 1000);
+    }
+    /**
+     * Stop session expiration monitoring interval
+     */
+    stopSessionExpirationMonitoring() {
+        if (this.sessionExpirationCheckInterval) {
+            clearInterval(this.sessionExpirationCheckInterval);
+            this.sessionExpirationCheckInterval = null;
+        }
+    }
+    /**
+     * Check session expiration and trigger callbacks if needed
+     *
+     * Note: ใช้ token expiration time เป็นตัวประมาณ session expiration
+     * เพราะเราไม่มี session creation time หรือ last activity time ใน SDK
+     * Token expiration จะถูก refresh อัตโนมัติเมื่อมีการใช้งาน (extend_on_activity)
+     */
+    checkSessionExpiration() {
+        if (!this.token || !this.sessionExpirationCallbacks || !this.sessionManagementConfig) {
+            return;
+        }
+        // Check if token is expired
+        if ((0, token_utils_1.isTokenExpired)(this.token)) {
+            if (this.sessionExpirationCallbacks.onSessionExpired) {
+                this.sessionExpirationCallbacks.onSessionExpired();
+            }
+            return;
+        }
+        const tokenExpirationMinutes = (0, token_utils_1.getTokenExpirationMinutes)(this.token);
+        if (tokenExpirationMinutes === null) {
+            return;
+        }
+        // ใช้ token expiration time เป็นตัวประมาณ session expiration
+        // เพราะ token จะถูก refresh อัตโนมัติเมื่อมีการใช้งาน (extend_on_activity)
+        // ดังนั้น token expiration time จะสะท้อน session expiration time ได้ดีพอสมควร
+        // ตรวจสอบว่า session expiration monitoring เปิดใช้งานหรือไม่
+        const inactivityEnabled = this.sessionManagementConfig.inactivity.enabled;
+        const lifetimeEnabled = this.sessionManagementConfig.lifetime.enabled;
+        // ถ้าไม่มี expiration config เปิดใช้งาน ให้ใช้ token expiration
+        if (!inactivityEnabled && !lifetimeEnabled) {
+            // ใช้ token expiration time เป็นตัวประมาณ
+            const warningMinutes = this.sessionManagementConfig.inactivity.warning_minutes;
+            if (tokenExpirationMinutes <= warningMinutes && tokenExpirationMinutes > 0) {
+                this.triggerExpiringWarning(tokenExpirationMinutes, 'inactivity');
+            }
+            return;
+        }
+        // คำนวณ session expiration times จาก config
+        const inactivityTimeoutMinutes = inactivityEnabled
+            ? (0, token_utils_1.convertDurationToMinutes)(this.sessionManagementConfig.inactivity.timeout_duration, this.sessionManagementConfig.inactivity.timeout_unit)
+            : null;
+        const lifetimeMaxMinutes = lifetimeEnabled
+            ? (0, token_utils_1.convertDurationToMinutes)(this.sessionManagementConfig.lifetime.max_duration, this.sessionManagementConfig.lifetime.max_unit)
+            : null;
+        // ใช้ token expiration time เป็นตัวประมาณ session expiration
+        // เพราะ token จะถูก refresh อัตโนมัติเมื่อมีการใช้งาน
+        // ดังนั้น token expiration time จะสะท้อน session expiration time ได้ดีพอสมควร
+        const warningMinutes = this.sessionManagementConfig.inactivity.warning_minutes;
+        // ตรวจสอบว่า token expiration time ใกล้หมดอายุตาม warning_minutes หรือไม่
+        if (tokenExpirationMinutes <= warningMinutes && tokenExpirationMinutes > 0) {
+            // กำหนด expiration type จาก config
+            let expirationType = 'inactivity';
+            if (inactivityTimeoutMinutes !== null && lifetimeMaxMinutes !== null) {
+                // ใช้ type ที่สั้นกว่า
+                expirationType = inactivityTimeoutMinutes <= lifetimeMaxMinutes ? 'inactivity' : 'lifetime';
+            }
+            else if (lifetimeMaxMinutes !== null) {
+                expirationType = 'lifetime';
+            }
+            this.triggerExpiringWarning(tokenExpirationMinutes, expirationType);
+        }
+    }
+    /**
+     * Trigger expiring warning callback with cooldown
+     */
+    triggerExpiringWarning(remainingMinutes, expirationType) {
+        if (!this.sessionExpirationCallbacks?.onSessionExpiring) {
+            return;
+        }
+        // Check cooldown to avoid spam
+        const now = Date.now();
+        const timeSinceLastWarning = now - this.lastWarningTime;
+        if (timeSinceLastWarning >= WARNING_COOLDOWN_MS) {
+            this.lastWarningTime = now;
+            this.sessionExpirationCallbacks.onSessionExpiring(remainingMinutes, expirationType);
+        }
+    }
+    /**
+     * Reload session management config (for when config changes)
+     */
+    async reloadSessionManagementConfig() {
+        this.sessionManagementConfigPromise = null;
+        this.sessionManagementConfig = null;
+        await this.loadSessionManagementConfig();
+    }
+    /**
+     * Enable inactivity detection
+     * จับ user activity (mouse/keyboard/touch/scroll) และ trigger callback เมื่อ inactivity timeout
+     *
+     * @param options - Options for inactivity detection
+     *
+     * @example
+     * ```typescript
+     * await authClient.enableInactivityDetection({
+     *   callbacks: {
+     *     onInactivityWarning: (remainingSeconds) => {
+     *       console.log(`Inactivity warning: ${remainingSeconds} seconds remaining`);
+     *       // แสดง notification หรือ dialog
+     *     },
+     *     onInactivityTimeout: () => {
+     *       console.log('Inactivity timeout');
+     *       // Redirect to login หรือ logout
+     *       authClient.clearToken();
+     *       window.location.href = '/login';
+     *     }
+     *   },
+     *   timeoutSeconds: 1800, // 30 minutes (optional, default: จาก session management config)
+     *   warningSeconds: 300, // 5 minutes warning (optional, default: จาก session management config)
+     *   events: ['mousemove', 'keydown', 'touchstart', 'scroll'] // (optional, default: ทั้งหมด)
+     * });
+     * ```
+     */
+    async enableInactivityDetection(options) {
+        // Disable existing detection if any
+        this.disableInactivityDetection();
+        this.inactivityCallbacks = options.callbacks;
+        // Load session management config if not loaded
+        if (!this.sessionManagementConfig) {
+            await this.loadSessionManagementConfig();
+        }
+        // Determine timeout and warning seconds
+        if (options.timeoutSeconds !== undefined) {
+            this.inactivityTimeoutSeconds = options.timeoutSeconds;
+        }
+        else if (this.sessionManagementConfig?.inactivity.enabled) {
+            // Use session management config
+            this.inactivityTimeoutSeconds =
+                (0, token_utils_1.convertDurationToMinutes)(this.sessionManagementConfig.inactivity.timeout_duration, this.sessionManagementConfig.inactivity.timeout_unit) * 60; // Convert to seconds
+        }
+        else {
+            // Default: 30 minutes
+            this.inactivityTimeoutSeconds = DEFAULT_INACTIVITY_TIMEOUT_SECONDS;
+        }
+        if (options.warningSeconds !== undefined) {
+            this.inactivityWarningSeconds = options.warningSeconds;
+        }
+        else if (this.sessionManagementConfig?.inactivity.warning_minutes) {
+            // Use session management config (convert minutes to seconds)
+            this.inactivityWarningSeconds = this.sessionManagementConfig.inactivity.warning_minutes * 60;
+        }
+        else {
+            // Default: 5 minutes
+            this.inactivityWarningSeconds = DEFAULT_WARNING_SECONDS;
+        }
+        // Determine events to listen
+        this.activityEvents = options.events || ['mousemove', 'keydown', 'touchstart', 'scroll'];
+        // Initialize last activity time
+        this.lastActivityTime = Date.now();
+        // Enable detection
+        this.inactivityDetectionEnabled = true;
+        // Setup event listeners
+        this.setupActivityListeners();
+        // Start timer
+        this.resetInactivityTimer();
+        logger_1.logger.debug('Inactivity detection enabled:', {
+            timeoutSeconds: this.inactivityTimeoutSeconds,
+            warningSeconds: this.inactivityWarningSeconds,
+            events: this.activityEvents,
+        });
+    }
+    /**
+     * Disable inactivity detection
+     */
+    disableInactivityDetection() {
+        this.inactivityDetectionEnabled = false;
+        // Clear throttle timeout
+        if (this.activityThrottleTimeout) {
+            clearTimeout(this.activityThrottleTimeout);
+            this.activityThrottleTimeout = null;
+        }
+        // Clear timeouts
+        this.clearInactivityTimeouts();
+        // Remove event listeners
+        this.removeActivityListeners();
+        // Reset state
+        this.inactivityCallbacks = null;
+        this.lastActivityTime = 0;
+        this.inactivityTimeoutSeconds = 0;
+        this.inactivityWarningSeconds = 0;
+        this.activityEvents = [];
+        logger_1.logger.debug('Inactivity detection disabled');
+    }
+    /**
+     * Handle user activity - reset inactivity timer with throttle
+     */
+    handleUserActivity() {
+        if (!this.inactivityDetectionEnabled) {
+            return;
+        }
+        // Throttle: reset timer สูงสุดทุก 1 วินาที เพื่อลด CPU usage
+        if (this.activityThrottleTimeout) {
+            return;
+        }
+        this.lastActivityTime = Date.now();
+        this.resetInactivityTimer();
+        this.activityThrottleTimeout = setTimeout(() => {
+            this.activityThrottleTimeout = null;
+        }, this.activityThrottleMs);
+    }
+    /**
+     * Setup activity event listeners
+     */
+    setupActivityListeners() {
+        if (typeof window === 'undefined') {
+            logger_1.logger.warn('Cannot setup activity listeners: window is undefined (SSR)');
+            return;
+        }
+        // Remove existing listeners if any
+        this.removeActivityListeners();
+        // Create handler
+        const handler = () => {
+            this.handleUserActivity();
+        };
+        this.activityHandler = handler;
+        // Setup listeners for each event type
+        this.activityEvents.forEach((eventType) => {
+            window.addEventListener(eventType, handler, { passive: true });
+        });
+        logger_1.logger.debug('Activity listeners setup:', this.activityEvents);
+    }
+    /**
+     * Remove activity event listeners
+     */
+    removeActivityListeners() {
+        if (typeof window === 'undefined' || !this.activityHandler) {
+            return;
+        }
+        const handler = this.activityHandler;
+        this.activityEvents.forEach((eventType) => {
+            window.removeEventListener(eventType, handler);
+        });
+        this.activityHandler = null;
+        logger_1.logger.debug('Activity listeners removed');
+    }
+    /**
+     * Clear inactivity timeouts (helper method)
+     */
+    clearInactivityTimeouts() {
+        if (this.inactivityWarningTimeout) {
+            clearTimeout(this.inactivityWarningTimeout);
+            this.inactivityWarningTimeout = null;
+        }
+        if (this.inactivityTimeout) {
+            clearTimeout(this.inactivityTimeout);
+            this.inactivityTimeout = null;
+        }
+    }
+    /**
+     * Reset inactivity timer
+     */
+    resetInactivityTimer() {
+        // Clear existing timeouts
+        this.clearInactivityTimeouts();
+        if (!this.inactivityDetectionEnabled || !this.inactivityCallbacks) {
+            return;
+        }
+        const now = Date.now();
+        this.lastActivityTime = now;
+        // Setup warning timeout
+        if (this.inactivityWarningSeconds > 0 && this.inactivityCallbacks.onInactivityWarning) {
+            const warningTime = this.inactivityTimeoutSeconds - this.inactivityWarningSeconds;
+            if (warningTime > 0) {
+                const timerStartTime = now; // Capture start time for this timer
+                this.inactivityWarningTimeout = setTimeout(() => {
+                    // Calculate remaining seconds based on when timer was set
+                    const elapsedSeconds = (Date.now() - timerStartTime) / 1000;
+                    const remainingSeconds = this.inactivityTimeoutSeconds - elapsedSeconds;
+                    if (this.inactivityCallbacks?.onInactivityWarning && remainingSeconds > 0) {
+                        this.inactivityCallbacks.onInactivityWarning(Math.floor(remainingSeconds));
+                    }
+                }, warningTime * 1000);
+            }
+        }
+        // Setup timeout
+        this.inactivityTimeout = setTimeout(() => {
+            if (this.inactivityCallbacks?.onInactivityTimeout) {
+                this.inactivityCallbacks.onInactivityTimeout();
+            }
+        }, this.inactivityTimeoutSeconds * 1000);
+    }
+    /**
+     * Check inactivity timeout and trigger callbacks if needed
+     */
+    checkInactivityTimeout() {
+        if (!this.inactivityDetectionEnabled || !this.inactivityCallbacks) {
+            return;
+        }
+        const now = Date.now();
+        const inactiveSeconds = (now - this.lastActivityTime) / 1000;
+        // Check if timeout reached
+        if (inactiveSeconds >= this.inactivityTimeoutSeconds) {
+            if (this.inactivityCallbacks.onInactivityTimeout) {
+                this.inactivityCallbacks.onInactivityTimeout();
+            }
+            return;
+        }
+        // Check if warning should be triggered
+        const remainingSeconds = this.inactivityTimeoutSeconds - inactiveSeconds;
+        if (remainingSeconds <= this.inactivityWarningSeconds &&
+            remainingSeconds > 0 &&
+            this.inactivityCallbacks.onInactivityWarning) {
+            this.inactivityCallbacks.onInactivityWarning(Math.floor(remainingSeconds));
+        }
+    }
 }
 exports.AuthClient = AuthClient;