@pushler/js 1.1.1 → 1.2.0

package/dist/pushler-ru.esm.js

@@ -20,6 +20,18 @@ const ConnectionStates = {
   FAILED: 'failed'
 };
 
+/**
+ * Состояния подписки на канал
+ */
+const SubscriptionStates = {
+  PENDING: 'pending',
+  PENDING_AUTH: 'pending_auth',
+  SUBSCRIBING: 'subscribing',
+  SUBSCRIBED: 'subscribed',
+  FAILED: 'failed',
+  UNSUBSCRIBED: 'unsubscribed'
+};
+
 /**
  * События WebSocket
  */
@@ -61,6 +73,7 @@ class Channel {
     this.name = name;
     this.options = options;
     this.subscribed = false;
+    this.subscriptionState = SubscriptionStates.PENDING;
     this.eventListeners = new Map();
     this.presenceData = null;
   }
@@ -108,6 +121,7 @@ class Channel {
    */
   handleAuthSuccess(data) {
     this.subscribed = true;
+    this.subscriptionState = SubscriptionStates.SUBSCRIBED;
     this.emit(Events.CHANNEL_SUBSCRIBED, data);
     
     // Для presence каналов сохраняем данные пользователя
@@ -135,6 +149,7 @@ class Channel {
     }
     
     this.subscribed = false;
+    this.subscriptionState = SubscriptionStates.UNSUBSCRIBED;
     this.emit(Events.CHANNEL_UNSUBSCRIBED);
   }
 
@@ -145,6 +160,14 @@ class Channel {
     return this.subscribed;
   }
 
+  /**
+   * Получение состояния подписки
+   * @returns {string} Состояние подписки
+   */
+  getSubscriptionState() {
+    return this.subscriptionState;
+  }
+
   /**
    * Получение данных присутствия (для presence каналов)
    */
@@ -215,6 +238,7 @@ class PushlerClient {
     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;
@@ -403,31 +427,98 @@ class PushlerClient {
     };
   }
 
+  /**
+   * Разбор склеенных 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);
     }
   }
 
@@ -488,7 +579,13 @@ class PushlerClient {
     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);
@@ -501,11 +598,31 @@ class PushlerClient {
    * Обработка ошибки аутентификации
    */
   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
     });
   }
 
@@ -563,8 +680,12 @@ class PushlerClient {
     // Поддерживаем оба формата имени
     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);
@@ -599,41 +720,119 @@ class PushlerClient {
 
   /**
    * Аутентификация канала
+   * С поддержкой отмены при 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) {
       // Статические заголовки
@@ -643,6 +842,19 @@ class PushlerClient {
     return headers;
   }
 
+  /**
+   * Установка токена авторизации
+   * Удобный метод для установки Bearer токена без создания функции
+   * @param {string} token - JWT токен
+   */
+  setAuthToken(token) {
+    if (token) {
+      this.authHeaders = { 'Authorization': `Bearer ${token}` };
+    } else {
+      this.authHeaders = null;
+    }
+  }
+
   /**
    * Получение подписи с бэкенда
    */
@@ -652,7 +864,8 @@ class PushlerClient {
       ? 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, {
@@ -909,6 +1122,69 @@ class PushlerClient {
     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;
@@ -1343,8 +1619,11 @@ const Pushler = {
   Channel: Channel$1,
   ChannelTypes,
   ConnectionStates,
+  SubscriptionStates,
+  ErrorCodes,
+  Events,
   generateSocketId
 };
 
-export { Channel$1 as Channel, ChannelTypes, ConnectionStates, Pushler, PushlerClient$1 as PushlerClient, PushlerServer$1 as PushlerServer, Pushler as default, generateSocketId };
+export { Channel$1 as Channel, ChannelTypes, ConnectionStates, ErrorCodes, Events, Pushler, PushlerClient$1 as PushlerClient, PushlerServer$1 as PushlerServer, SubscriptionStates, Pushler as default, generateSocketId };
 //# sourceMappingURL=pushler-ru.esm.js.map