@pushler/js 1.1.1 → 1.2.0

package/dist/pushler-ru.js

@@ -24,6 +24,18 @@
     FAILED: 'failed'
   };
 
+  /**
+   * Состояния подписки на канал
+   */
+  const SubscriptionStates = {
+    PENDING: 'pending',
+    PENDING_AUTH: 'pending_auth',
+    SUBSCRIBING: 'subscribing',
+    SUBSCRIBED: 'subscribed',
+    FAILED: 'failed',
+    UNSUBSCRIBED: 'unsubscribed'
+  };
+
   /**
    * События WebSocket
    */
@@ -65,6 +77,7 @@
       this.name = name;
       this.options = options;
       this.subscribed = false;
+      this.subscriptionState = SubscriptionStates.PENDING;
       this.eventListeners = new Map();
       this.presenceData = null;
     }
@@ -112,6 +125,7 @@
      */
     handleAuthSuccess(data) {
       this.subscribed = true;
+      this.subscriptionState = SubscriptionStates.SUBSCRIBED;
       this.emit(Events.CHANNEL_SUBSCRIBED, data);
       
       // Для presence каналов сохраняем данные пользователя
@@ -139,6 +153,7 @@
       }
       
       this.subscribed = false;
+      this.subscriptionState = SubscriptionStates.UNSUBSCRIBED;
       this.emit(Events.CHANNEL_UNSUBSCRIBED);
     }
 
@@ -149,6 +164,14 @@
       return this.subscribed;
     }
 
+    /**
+     * Получение состояния подписки
+     * @returns {string} Состояние подписки
+     */
+    getSubscriptionState() {
+      return this.subscriptionState;
+    }
+
     /**
      * Получение данных присутствия (для presence каналов)
      */
@@ -219,6 +242,7 @@
       this.channels = new Map(); // Хранит каналы по полному имени (с appKey)
       this.channelAliases = new Map(); // Маппинг оригинальное имя -> полное имя
       this.eventListeners = new Map();
+      this.pendingAuthRequests = new Map(); // Отслеживание pending auth запросов для отмены при unsubscribe
       this.reconnectAttempts = 0;
       this.reconnectTimer = null;
       this.authTimeout = null;
@@ -407,31 +431,98 @@
       };
     }
 
+    /**
+     * Разбор склеенных JSON из одного WebSocket фрейма
+     * Сервер иногда отправляет несколько JSON объектов подряд в одном фрейме:
+     * {"event":"a",...}{"event":"b",...}
+     * @param {string} str - Строка с одним или несколькими JSON объектами
+     * @returns {string[]} Массив отдельных JSON строк
+     */
+    splitConcatenatedJSON(str) {
+      const results = [];
+      let depth = 0;
+      let start = 0;
+      let inString = false;
+      let escape = false;
+      
+      for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        
+        // Обработка escape-символов внутри строк
+        if (escape) {
+          escape = false;
+          continue;
+        }
+        
+        if (char === '\\' && inString) {
+          escape = true;
+          continue;
+        }
+        
+        // Отслеживание строковых литералов
+        if (char === '"') {
+          inString = !inString;
+          continue;
+        }
+        
+        // Считаем скобки только вне строк
+        if (!inString) {
+          if (char === '{') {
+            depth++;
+          } else if (char === '}') {
+            depth--;
+            if (depth === 0) {
+              results.push(str.slice(start, i + 1));
+              start = i + 1;
+            }
+          }
+        }
+      }
+      
+      return results;
+    }
+
     /**
      * Обработка входящих сообщений
      */
     handleMessage(event) {
       try {
-        const message = JSON.parse(event.data);
+        // Пытаемся распарсить как один JSON
+        const messages = this.splitConcatenatedJSON(event.data);
         
-        switch (message.event) {
-          case 'pushler:connection_established':
-            this.handleConnectionEstablished(message.data);
-            break;
-          case 'pushler:subscription_succeeded':
-            this.handleSubscriptionSucceeded(message);
-            break;
-          case 'pushler:auth_success':
-            this.handleAuthSuccess(message);
-            break;
-          case 'pushler:auth_error':
-            this.handleAuthError(message);
-            break;
-          default:
-            this.handleChannelMessage(message);
+        // Если несколько JSON объектов, обрабатываем каждый
+        for (const jsonStr of messages) {
+          try {
+            const message = JSON.parse(jsonStr);
+            this.processMessage(message);
+          } catch (parseError) {
+            console.error('Error parsing JSON message:', parseError, 'Raw:', jsonStr);
+          }
         }
       } catch (error) {
-        console.error('Error parsing WebSocket message:', error);
+        console.error('Error handling WebSocket message:', error);
+      }
+    }
+
+    /**
+     * Обработка распарсенного сообщения
+     */
+    processMessage(message) {
+      switch (message.event) {
+        case 'pushler:connection_established':
+          this.handleConnectionEstablished(message.data);
+          break;
+        case 'pushler:subscription_succeeded':
+          this.handleSubscriptionSucceeded(message);
+          break;
+        case 'pushler:auth_success':
+          this.handleAuthSuccess(message);
+          break;
+        case 'pushler:auth_error':
+          this.handleAuthError(message);
+          break;
+        default:
+          this.handleChannelMessage(message);
       }
     }
 
@@ -492,7 +583,13 @@
       const { channel } = message.data;
       const channelInstance = this.channels.get(channel);
       
+      // Очищаем pending auth запрос
+      this.cancelPendingAuth(channel);
+      
       if (channelInstance) {
+        // Устанавливаем состояние subscribed
+        channelInstance.subscriptionState = SubscriptionStates.SUBSCRIBED;
+        
         // На сервере уже происходит подписка после успешной авторизации,
         // поэтому просто помечаем канал как подписанный
         channelInstance.handleAuthSuccess(message.data);
@@ -505,11 +602,31 @@
      * Обработка ошибки аутентификации
      */
     handleAuthError(message) {
-      const { error } = message.data;
-      this.emit(Events.CHANNEL_AUTH_ERROR, error);
+      const { error, channel } = message.data;
+      const channelName = channel || null;
+      
+      // Очищаем pending auth запрос
+      if (channelName) {
+        this.cancelPendingAuth(channelName);
+        
+        const channelInstance = this.channels.get(channelName);
+        if (channelInstance) {
+          channelInstance.subscriptionState = SubscriptionStates.FAILED;
+        }
+      }
+      
+      const originalChannelName = channelName ? this.extractChannelName(channelName) : null;
+      
+      this.emit(Events.CHANNEL_AUTH_ERROR, {
+        error,
+        channel: originalChannelName,
+        socketId: this.socketId
+      });
       this.emit(Events.ERROR, {
         code: ErrorCodes.AUTHENTICATION_FAILED,
-        message: error
+        message: error,
+        channel: originalChannelName,
+        socketId: this.socketId
       });
     }
 
@@ -567,8 +684,12 @@
       // Поддерживаем оба формата имени
       const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
       
+      // Отменяем pending auth запросы для этого канала (исправление race condition)
+      this.cancelPendingAuth(fullChannelName);
+      
       const channel = this.channels.get(fullChannelName);
       if (channel) {
+        channel.subscriptionState = SubscriptionStates.UNSUBSCRIBED;
         channel.unsubscribe();
         this.channels.delete(fullChannelName);
         this.channelAliases.delete(channel.originalName || channelName);
@@ -603,41 +724,119 @@
 
     /**
      * Аутентификация канала
+     * С поддержкой отмены при unsubscribe
      */
     async authenticateChannel(channel) {
+      // Создаём AbortController для возможности отмены
+      const abortController = new AbortController();
+      const channelName = channel.name;
+      
+      // Сохраняем для возможности отмены при unsubscribe
+      this.pendingAuthRequests.set(channelName, {
+        controller: abortController,
+        timeoutId: null
+      });
+      
+      // Устанавливаем состояние канала
+      channel.subscriptionState = SubscriptionStates.PENDING_AUTH;
+      
       try {
+        // Проверка отмены перед началом
+        if (abortController.signal.aborted) {
+          return;
+        }
+        
         const authData = await this.getChannelAuthData(channel);
         
+        // Проверка отмены после получения данных
+        if (abortController.signal.aborted) {
+          return;
+        }
+        
         this.sendMessage({
           event: 'pushler:auth',
           data: authData
         });
         
         // Устанавливаем таймаут аутентификации
-        this.authTimeout = setTimeout(() => {
+        const timeoutId = setTimeout(() => {
+          // Не отправляем ошибку, если запрос уже отменён
+          if (abortController.signal.aborted) {
+            return;
+          }
+          
+          // Очищаем pending запрос
+          this.pendingAuthRequests.delete(channelName);
+          
+          // Устанавливаем состояние failed
+          channel.subscriptionState = SubscriptionStates.FAILED;
+          
           this.emit(Events.ERROR, {
             code: ErrorCodes.AUTHENTICATION_TIMEOUT,
-            message: 'Authentication timeout'
+            message: 'Authentication timeout',
+            channel: channel.originalName || this.extractChannelName(channelName),
+            socketId: this.socketId
           });
         }, 10000);
         
+        // Сохраняем timeoutId для возможности очистки
+        const pending = this.pendingAuthRequests.get(channelName);
+        if (pending) {
+          pending.timeoutId = timeoutId;
+        }
+        
       } catch (error) {
+        // Не отправляем ошибку, если запрос уже отменён
+        if (abortController.signal.aborted) {
+          return;
+        }
+        
+        // Очищаем pending запрос
+        this.pendingAuthRequests.delete(channelName);
+        
+        // Устанавливаем состояние failed
+        channel.subscriptionState = SubscriptionStates.FAILED;
+        
         this.emit(Events.ERROR, {
           code: ErrorCodes.AUTHENTICATION_FAILED,
-          message: error.message
+          message: error.message,
+          channel: channel.originalName || this.extractChannelName(channelName),
+          socketId: this.socketId
         });
       }
     }
 
+    /**
+     * Отмена pending auth запроса для канала
+     */
+    cancelPendingAuth(channelName) {
+      const pending = this.pendingAuthRequests.get(channelName);
+      if (pending) {
+        // Отменяем запрос
+        pending.controller.abort();
+        
+        // Очищаем таймаут
+        if (pending.timeoutId) {
+          clearTimeout(pending.timeoutId);
+        }
+        
+        // Удаляем из карты
+        this.pendingAuthRequests.delete(channelName);
+      }
+    }
+
     /**
      * Получение заголовков для авторизации
+     * Поддерживает как синхронные, так и асинхронные функции getAuthHeaders
+     * @returns {Promise<Object>} Заголовки для авторизации
      */
-    getAuthRequestHeaders() {
+    async getAuthRequestHeaders() {
       const headers = { 'Content-Type': 'application/json' };
       
       // Динамические заголовки имеют приоритет
       if (typeof this.getAuthHeaders === 'function') {
-        const dynamicHeaders = this.getAuthHeaders();
+        // Поддержка асинхронных функций (AsyncStorage, SecureStore, Keychain)
+        const dynamicHeaders = await Promise.resolve(this.getAuthHeaders());
         Object.assign(headers, dynamicHeaders);
       } else if (this.authHeaders) {
         // Статические заголовки
@@ -647,6 +846,19 @@
       return headers;
     }
 
+    /**
+     * Установка токена авторизации
+     * Удобный метод для установки Bearer токена без создания функции
+     * @param {string} token - JWT токен
+     */
+    setAuthToken(token) {
+      if (token) {
+        this.authHeaders = { 'Authorization': `Bearer ${token}` };
+      } else {
+        this.authHeaders = null;
+      }
+    }
+
     /**
      * Получение подписи с бэкенда
      */
@@ -656,7 +868,8 @@
         ? this.authEndpoint 
         : `${this.apiUrl}${this.authEndpoint}`;
       
-      const headers = this.getAuthRequestHeaders();
+      // Асинхронное получение заголовков (поддержка AsyncStorage/SecureStore)
+      const headers = await this.getAuthRequestHeaders();
       const hasAuthHeaders = this.authHeaders || this.getAuthHeaders;
       
       const response = await fetch(authUrl, {
@@ -913,6 +1126,69 @@
       const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
       return this.channels.get(fullChannelName);
     }
+
+    /**
+     * Проверка подписки на канал
+     * @param {string} channelName - Имя канала
+     * @returns {boolean} true если подписан
+     */
+    isSubscribed(channelName) {
+      const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+      const channel = this.channels.get(fullChannelName);
+      return channel ? channel.subscribed : false;
+    }
+
+    /**
+     * Получение состояния подписки на канал
+     * @param {string} channelName - Имя канала
+     * @returns {string|null} Состояние подписки или null если канал не найден
+     */
+    getSubscriptionState(channelName) {
+      const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+      const channel = this.channels.get(fullChannelName);
+      
+      if (!channel) {
+        return null;
+      }
+      
+      return channel.subscriptionState || (channel.subscribed ? SubscriptionStates.SUBSCRIBED : SubscriptionStates.PENDING);
+    }
+
+    /**
+     * Получение списка подписанных каналов
+     * @returns {string[]} Массив имён подписанных каналов
+     */
+    getSubscribedChannels() {
+      const subscribedChannels = [];
+      
+      for (const [fullName, channel] of this.channels.entries()) {
+        if (channel.subscribed) {
+          subscribedChannels.push(channel.originalName || this.extractChannelName(fullName));
+        }
+      }
+      
+      return subscribedChannels;
+    }
+
+    /**
+     * Получение всех каналов с их состояниями
+     * @returns {Object[]} Массив объектов с информацией о каналах
+     */
+    getAllChannelsInfo() {
+      const channelsInfo = [];
+      
+      for (const [fullName, channel] of this.channels.entries()) {
+        channelsInfo.push({
+          name: channel.originalName || this.extractChannelName(fullName),
+          fullName: fullName,
+          subscribed: channel.subscribed,
+          state: channel.subscriptionState || (channel.subscribed ? SubscriptionStates.SUBSCRIBED : SubscriptionStates.PENDING),
+          type: channel.getType()
+        });
+      }
+      
+      return channelsInfo;
+    }
   }
 
   var PushlerClient$1 = PushlerClient;
@@ -1347,15 +1623,21 @@
     Channel: Channel$1,
     ChannelTypes,
     ConnectionStates,
+    SubscriptionStates,
+    ErrorCodes,
+    Events,
     generateSocketId
   };
 
   exports.Channel = Channel$1;
   exports.ChannelTypes = ChannelTypes;
   exports.ConnectionStates = ConnectionStates;
+  exports.ErrorCodes = ErrorCodes;
+  exports.Events = Events;
   exports.Pushler = Pushler;
   exports.PushlerClient = PushlerClient$1;
   exports.PushlerServer = PushlerServer$1;
+  exports.SubscriptionStates = SubscriptionStates;
   exports.default = Pushler;
   exports.generateSocketId = generateSocketId;