@pushler/js 1.0.0

package/dist/pushler-ru.js

@@ -0,0 +1,1253 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('crypto')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'crypto'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Pushler = {}, global.crypto));
+})(this, (function (exports, crypto) { 'use strict';
+
+  /**
+   * Типы каналов
+   */
+  const ChannelTypes = {
+    PUBLIC: 'public',
+    PRIVATE: 'private',
+    PRESENCE: 'presence'
+  };
+
+  /**
+   * Состояния подключения
+   */
+  const ConnectionStates = {
+    CONNECTING: 'connecting',
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    RECONNECTING: 'reconnecting',
+    FAILED: 'failed'
+  };
+
+  /**
+   * События WebSocket
+   */
+  const Events = {
+    // События подключения
+    CONNECTION_STATE_CHANGED: 'connection_state_changed',
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    ERROR: 'error',
+    
+    // События каналов
+    CHANNEL_SUBSCRIBED: 'channel_subscribed',
+    CHANNEL_UNSUBSCRIBED: 'channel_unsubscribed',
+    CHANNEL_AUTH_SUCCESS: 'pushler:auth_success',
+    CHANNEL_AUTH_ERROR: 'pushler:auth_error',
+    
+    // События сообщений
+    MESSAGE_RECEIVED: 'message_received'
+  };
+
+  /**
+   * Коды ошибок
+   */
+  const ErrorCodes = {
+    INVALID_APP_KEY: 'INVALID_APP_KEY',
+    INVALID_SIGNATURE: 'INVALID_SIGNATURE',
+    AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
+    CHANNEL_ACCESS_DENIED: 'CHANNEL_ACCESS_DENIED',
+    CONNECTION_FAILED: 'CONNECTION_FAILED',
+    AUTHENTICATION_TIMEOUT: 'AUTHENTICATION_TIMEOUT'
+  };
+
+  /**
+   * Класс для управления каналом
+   */
+  class Channel {
+    constructor(client, name, options = {}) {
+      this.client = client;
+      this.name = name;
+      this.options = options;
+      this.subscribed = false;
+      this.eventListeners = new Map();
+      this.presenceData = null;
+    }
+
+    /**
+     * Подписка на событие канала
+     */
+    on(event, callback) {
+      if (!this.eventListeners.has(event)) {
+        this.eventListeners.set(event, []);
+      }
+      this.eventListeners.get(event).push(callback);
+    }
+
+    /**
+     * Отписка от события канала
+     */
+    off(event, callback) {
+      if (this.eventListeners.has(event)) {
+        const listeners = this.eventListeners.get(event);
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    }
+
+    /**
+     * Вызов события канала
+     */
+    emit(event, data) {
+      if (this.eventListeners.has(event)) {
+        this.eventListeners.get(event).forEach(callback => {
+          try {
+            callback(data);
+          } catch (error) {
+            console.error('Error in channel event listener:', error);
+          }
+        });
+      }
+    }
+
+    /**
+     * Обработка успешной аутентификации
+     */
+    handleAuthSuccess(data) {
+      this.subscribed = true;
+      this.emit(Events.CHANNEL_SUBSCRIBED, data);
+      
+      // Для presence каналов сохраняем данные пользователя
+      if (data.user) {
+        this.presenceData = data.user;
+      }
+    }
+
+    /**
+     * Обработка входящих сообщений
+     */
+    handleMessage(event, data) {
+      this.emit(event, data);
+    }
+
+    /**
+     * Отписка от канала
+     */
+    unsubscribe() {
+      if (this.subscribed && this.client.connectionState === 'connected') {
+        this.client.sendMessage({
+          event: 'pushler:unsubscribe',
+          data: { channel: this.name }
+        });
+      }
+      
+      this.subscribed = false;
+      this.emit(Events.CHANNEL_UNSUBSCRIBED);
+    }
+
+    /**
+     * Проверка подписки на канал
+     */
+    isSubscribed() {
+      return this.subscribed;
+    }
+
+    /**
+     * Получение данных присутствия (для presence каналов)
+     */
+    getPresenceData() {
+      return this.presenceData;
+    }
+
+    /**
+     * Получение типа канала
+     * Учитывает, что имя канала может иметь формат {appKey}:{channelName}
+     */
+    getType() {
+      // Извлекаем базовое имя канала (без appKey)
+      const baseName = this.getBaseName();
+      
+      if (baseName.startsWith('private-')) {
+        return ChannelTypes.PRIVATE;
+      }
+      if (baseName.startsWith('presence-')) {
+        return ChannelTypes.PRESENCE;
+      }
+      return ChannelTypes.PUBLIC;
+    }
+
+    /**
+     * Получение базового имени канала (без appKey префикса)
+     * @returns {string} Базовое имя канала
+     */
+    getBaseName() {
+      // Имя канала может быть в формате {appKey}:{channelName}
+      const colonIndex = this.name.indexOf(':');
+      if (colonIndex !== -1) {
+        return this.name.substring(colonIndex + 1);
+      }
+      return this.name;
+    }
+
+    /**
+     * Получение полного имени канала (с appKey)
+     * @returns {string} Полное имя канала
+     */
+    getFullName() {
+      return this.name;
+    }
+  }
+
+  var Channel$1 = Channel;
+
+  /**
+   * Основной класс для подключения к Pushler.ru WebSocket серверу
+   */
+  class PushlerClient {
+    constructor(options = {}) {
+      this.appKey = options.appKey;
+      this.wsUrl = options.wsUrl || 'ws://pushler.ru:8080/ws';
+      this.apiUrl = options.apiUrl;
+      this.authEndpoint = options.authEndpoint || '/pushler/auth'; // Путь для авторизации каналов
+      this.autoConnect = options.autoConnect !== false;
+      this.reconnectDelay = options.reconnectDelay || 1000;
+      this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
+      
+      this.connectionState = ConnectionStates.DISCONNECTED;
+      this.socket = null;
+      this.socketId = null;
+      this.channels = new Map(); // Хранит каналы по полному имени (с appKey)
+      this.channelAliases = new Map(); // Маппинг оригинальное имя -> полное имя
+      this.eventListeners = new Map();
+      this.reconnectAttempts = 0;
+      this.reconnectTimer = null;
+      this.authTimeout = null;
+      
+      // Автоматическое подключение
+      if (this.autoConnect) {
+        this.connect();
+      }
+    }
+
+    /**
+     * Формирование полного имени канала с префиксом appKey
+     * Формат: {appKey}:{channelName}
+     * @param {string} channelName - Оригинальное имя канала
+     * @returns {string} Полное имя канала
+     */
+    formatChannelName(channelName) {
+      // Если канал уже содержит appKey, возвращаем как есть
+      if (channelName.startsWith(this.appKey + ':')) {
+        return channelName;
+      }
+      return `${this.appKey}:${channelName}`;
+    }
+
+    /**
+     * Извлечение оригинального имени канала (без appKey)
+     * @param {string} fullChannelName - Полное имя канала
+     * @returns {string} Оригинальное имя канала
+     */
+    extractChannelName(fullChannelName) {
+      const prefix = this.appKey + ':';
+      if (fullChannelName.startsWith(prefix)) {
+        return fullChannelName.substring(prefix.length);
+      }
+      return fullChannelName;
+    }
+
+    /**
+     * Подключение к WebSocket серверу
+     */
+    connect() {
+      if (this.connectionState === ConnectionStates.CONNECTED || 
+          this.connectionState === ConnectionStates.CONNECTING) {
+        return;
+      }
+
+      this.connectionState = ConnectionStates.CONNECTING;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+
+      try {
+        if (!this.wsUrl) {
+          throw new Error('WebSocket URL is not configured');
+        }
+        
+        console.log(`PushlerClient: Connecting to ${this.wsUrl}`);
+        this.socket = new WebSocket(this.wsUrl);
+        this.setupWebSocketHandlers();
+      } catch (error) {
+        console.error('PushlerClient: Error creating WebSocket connection:', error);
+        this.handleConnectionError(error);
+      }
+    }
+
+    /**
+     * Настройка обработчиков WebSocket
+     */
+    setupWebSocketHandlers() {
+      this.socket.onopen = () => {
+        // Не устанавливаем CONNECTED здесь - ждем pushler:connection_established
+        // Это предотвращает двойные события и проблемы с переподключением
+        this.connectionState = ConnectionStates.CONNECTING;
+        this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+        console.log('WebSocket connection opened, waiting for connection_established...');
+      };
+
+      this.socket.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+
+      this.socket.onclose = (event) => {
+        this.connectionState = ConnectionStates.DISCONNECTED;
+        this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+        this.emit(Events.DISCONNECTED, event);
+        
+        // Логируем причину закрытия для отладки
+        if (event.code !== 1000) { // 1000 = нормальное закрытие
+          console.warn('WebSocket closed unexpectedly:', {
+            code: event.code,
+            reason: event.reason || 'No reason provided',
+            wasClean: event.wasClean,
+            url: this.wsUrl
+          });
+        }
+        
+        // Автоматическое переподключение
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.scheduleReconnect();
+        } else {
+          // Если превышено количество попыток, отправляем ошибку
+          this.emit(Events.ERROR, {
+            code: ErrorCodes.CONNECTION_FAILED,
+            message: `Failed to connect after ${this.maxReconnectAttempts} attempts. Please check if the WebSocket server is running at ${this.wsUrl}`,
+            url: this.wsUrl
+          });
+        }
+      };
+
+      this.socket.onerror = (error) => {
+        this.handleConnectionError(error);
+      };
+    }
+
+    /**
+     * Обработка входящих сообщений
+     */
+    handleMessage(event) {
+      try {
+        const message = JSON.parse(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);
+        }
+      } catch (error) {
+        console.error('Error parsing WebSocket message:', error);
+      }
+    }
+
+    /**
+     * Обработка установления соединения
+     */
+    handleConnectionEstablished(data) {
+      this.socketId = data.socket_id;
+      this.connectionState = ConnectionStates.CONNECTED;
+      this.reconnectAttempts = 0;
+      
+      console.log('Connection established with socket ID:', this.socketId);
+      
+      // Переподписываемся на все каналы после переподключения
+      this.resubscribeAllChannels();
+      
+      this.emit(Events.CONNECTED, { socketId: this.socketId });
+    }
+    
+    /**
+     * Переподписка на все каналы после переподключения
+     */
+    resubscribeAllChannels() {
+      for (const [channelName, channel] of this.channels.entries()) {
+        // Сбрасываем флаг подписки
+        channel.subscribed = false;
+        // Выполняем подписку заново
+        this.performChannelSubscription(channel);
+      }
+    }
+
+    /**
+     * Обработка успешной подписки на канал
+     */
+    handleSubscriptionSucceeded(message) {
+      const channel = message.channel;
+      const channelInstance = this.channels.get(channel);
+      
+      if (channelInstance) {
+        channelInstance.subscribed = true;
+        channelInstance.emit(Events.CHANNEL_SUBSCRIBED, message.data || {});
+        console.log(`Channel ${channel} subscribed successfully`);
+      }
+    }
+
+    /**
+     * Обработка успешной аутентификации
+     */
+    handleAuthSuccess(message) {
+      const { channel } = message.data;
+      const channelInstance = this.channels.get(channel);
+      
+      if (channelInstance) {
+        // На сервере уже происходит подписка после успешной авторизации,
+        // поэтому просто помечаем канал как подписанный
+        channelInstance.handleAuthSuccess(message.data);
+      }
+      
+      this.emit(Events.CHANNEL_AUTH_SUCCESS, message.data);
+    }
+
+    /**
+     * Обработка ошибки аутентификации
+     */
+    handleAuthError(message) {
+      const { error } = message.data;
+      this.emit(Events.CHANNEL_AUTH_ERROR, error);
+      this.emit(Events.ERROR, {
+        code: ErrorCodes.AUTHENTICATION_FAILED,
+        message: error
+      });
+    }
+
+    /**
+     * Обработка сообщений каналов
+     */
+    handleChannelMessage(message) {
+      const { channel, event, data } = message;
+      const channelInstance = this.channels.get(channel);
+      
+      if (channelInstance) {
+        channelInstance.handleMessage(event, data);
+      }
+      
+      // Для события возвращаем оригинальное имя канала (без appKey)
+      const originalChannelName = this.extractChannelName(channel);
+      this.emit(Events.MESSAGE_RECEIVED, { channel: originalChannelName, event, data });
+    }
+
+    /**
+     * Подписка на канал
+     * @param {string} channelName - Имя канала (без appKey, будет добавлен автоматически)
+     * @param {Object} options - Опции подписки
+     * @returns {Channel} Объект канала
+     */
+    subscribe(channelName, options = {}) {
+      // Формируем полное имя канала с appKey
+      const fullChannelName = this.formatChannelName(channelName);
+      
+      if (this.channels.has(fullChannelName)) {
+        return this.channels.get(fullChannelName);
+      }
+
+      // Создаем канал с полным именем
+      const channel = new Channel$1(this, fullChannelName, options);
+      // Сохраняем оригинальное имя для удобства
+      channel.originalName = channelName;
+      
+      this.channels.set(fullChannelName, channel);
+      this.channelAliases.set(channelName, fullChannelName);
+      
+      // Если подключены, сразу подписываемся
+      if (this.connectionState === ConnectionStates.CONNECTED) {
+        this.performChannelSubscription(channel);
+      }
+      
+      return channel;
+    }
+
+    /**
+     * Отписка от канала
+     * @param {string} channelName - Имя канала (можно использовать оригинальное или полное)
+     */
+    unsubscribe(channelName) {
+      // Поддерживаем оба формата имени
+      const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+      
+      const channel = this.channels.get(fullChannelName);
+      if (channel) {
+        channel.unsubscribe();
+        this.channels.delete(fullChannelName);
+        this.channelAliases.delete(channel.originalName || channelName);
+      }
+    }
+
+    /**
+     * Выполнение подписки на канал
+     */
+    performChannelSubscription(channel) {
+      if (this.connectionState !== ConnectionStates.CONNECTED) {
+        return;
+      }
+
+      const channelType = this.getChannelType(channel.name);
+      
+      // Для публичных каналов подписываемся сразу
+      if (channelType === ChannelTypes.PUBLIC) {
+        this.sendMessage({
+          event: 'pushler:subscribe',
+          data: { 
+            channel: channel.name,
+            app_key: this.appKey
+          }
+        });
+        return;
+      }
+
+      // Для приватных и presence каналов нужна аутентификация
+      this.authenticateChannel(channel);
+    }
+
+    /**
+     * Аутентификация канала
+     */
+    async authenticateChannel(channel) {
+      try {
+        const authData = await this.getChannelAuthData(channel);
+        
+        this.sendMessage({
+          event: 'pushler:auth',
+          data: authData
+        });
+        
+        // Устанавливаем таймаут аутентификации
+        this.authTimeout = setTimeout(() => {
+          this.emit(Events.ERROR, {
+            code: ErrorCodes.AUTHENTICATION_TIMEOUT,
+            message: 'Authentication timeout'
+          });
+        }, 10000);
+        
+      } catch (error) {
+        this.emit(Events.ERROR, {
+          code: ErrorCodes.AUTHENTICATION_FAILED,
+          message: error.message
+        });
+      }
+    }
+
+    /**
+     * Получение подписи с бэкенда
+     */
+    async getChannelSignature(channelName, socketId, userData = null) {
+      // Формируем URL: если authEndpoint абсолютный — используем его, иначе добавляем к apiUrl
+      const authUrl = this.authEndpoint.startsWith('http') 
+        ? this.authEndpoint 
+        : `${this.apiUrl}${this.authEndpoint}`;
+      
+      const response = await fetch(authUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          channel_name: channelName,
+          socket_id: socketId,
+          app_key: this.appKey,
+          user_data: userData
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || 'Failed to get channel signature');
+      }
+
+      const data = await response.json();
+      return data.signature;
+    }
+
+    /**
+     * Получение данных для аутентификации канала
+     */
+    async getChannelAuthData(channel) {
+      if (!this.socketId) {
+        throw new Error('Socket ID not available. Connection not established.');
+      }
+      
+      const channelType = this.getChannelType(channel.name);
+      
+      const authData = {
+        app_key: this.appKey,
+        channel: channel.name,
+        socket_id: this.socketId
+      };
+
+      // Для приватных и presence каналов нужна подпись
+      if (channelType === ChannelTypes.PRIVATE || channelType === ChannelTypes.PRESENCE) {
+        // Если подпись уже предоставлена, используем её
+        if (channel.options.signature) {
+          authData.signature = channel.options.signature;
+          console.log('Using provided signature:', {
+            channel: channel.name,
+            socketId: this.socketId,
+            signatureLength: channel.options.signature.length,
+            signature: channel.options.signature.substring(0, 20) + '...'
+          });
+        } else {
+          // Иначе получаем подпись с бэкенда
+          try {
+            authData.signature = await this.getChannelSignature(
+              channel.name, 
+              this.socketId, 
+              channel.options.user
+            );
+          } catch (error) {
+            throw new Error(`Failed to get channel signature: ${error.message}`);
+          }
+        }
+      }
+
+      // Для presence каналов нужны данные пользователя
+      if (channelType === ChannelTypes.PRESENCE) {
+        if (!channel.options.user) {
+          throw new Error('User data is required for presence channels');
+        }
+        
+        authData.user = channel.options.user;
+      }
+
+      return authData;
+    }
+
+    /**
+     * Определение типа канала
+     * Формат канала: {appKey}:{type-}channelName
+     */
+    getChannelType(channelName) {
+      // Извлекаем имя канала без appKey
+      const baseName = this.extractChannelName(channelName);
+      
+      if (baseName.startsWith('private-')) {
+        return ChannelTypes.PRIVATE;
+      }
+      if (baseName.startsWith('presence-')) {
+        return ChannelTypes.PRESENCE;
+      }
+      return ChannelTypes.PUBLIC;
+    }
+
+    /**
+     * Отправка сообщения через WebSocket
+     */
+    sendMessage(message) {
+      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+        this.socket.send(JSON.stringify(message));
+      }
+    }
+
+    /**
+     * Генерация уникального ID сокета
+     */
+    generateSocketId() {
+      return Math.random().toString(36).substr(2, 9) + '.' + Math.floor(Math.random() * 1000000);
+    }
+
+    /**
+     * Планирование переподключения
+     */
+    scheduleReconnect() {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+      }
+
+      this.reconnectAttempts++;
+      this.connectionState = ConnectionStates.RECONNECTING;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+
+      this.reconnectTimer = setTimeout(() => {
+        this.connect();
+      }, this.reconnectDelay * this.reconnectAttempts);
+    }
+
+    /**
+     * Обработка ошибки подключения
+     */
+    handleConnectionError(error) {
+      this.connectionState = ConnectionStates.FAILED;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+      
+      // Формируем более информативное сообщение об ошибке
+      let errorMessage = 'Connection failed';
+      if (error && error.message) {
+        errorMessage = error.message;
+      } else if (error && typeof error === 'object') {
+        errorMessage = JSON.stringify(error);
+      } else if (typeof error === 'string') {
+        errorMessage = error;
+      }
+      
+      // Добавляем информацию о URL для отладки
+      const fullErrorMessage = `WebSocket connection to '${this.wsUrl}' failed: ${errorMessage}`;
+      
+      console.error('PushlerClient connection error:', fullErrorMessage);
+      
+      this.emit(Events.ERROR, {
+        code: ErrorCodes.CONNECTION_FAILED,
+        message: fullErrorMessage,
+        url: this.wsUrl,
+        originalError: error
+      });
+    }
+
+    /**
+     * Отключение от WebSocket сервера
+     */
+    disconnect() {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      
+      if (this.authTimeout) {
+        clearTimeout(this.authTimeout);
+        this.authTimeout = null;
+      }
+
+      if (this.socket) {
+        this.socket.close();
+        this.socket = null;
+      }
+
+      // Очищаем каналы и алиасы
+      this.channels.clear();
+      this.channelAliases.clear();
+
+      this.connectionState = ConnectionStates.DISCONNECTED;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+    }
+
+    /**
+     * Подписка на событие
+     */
+    on(event, callback) {
+      if (!this.eventListeners.has(event)) {
+        this.eventListeners.set(event, []);
+      }
+      this.eventListeners.get(event).push(callback);
+    }
+
+    /**
+     * Отписка от события
+     */
+    off(event, callback) {
+      if (this.eventListeners.has(event)) {
+        const listeners = this.eventListeners.get(event);
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    }
+
+    /**
+     * Вызов события
+     */
+    emit(event, data) {
+      if (this.eventListeners.has(event)) {
+        this.eventListeners.get(event).forEach(callback => {
+          try {
+            callback(data);
+          } catch (error) {
+            console.error('Error in event listener:', error);
+          }
+        });
+      }
+    }
+
+    /**
+     * Получение состояния подключения
+     */
+    getConnectionState() {
+      return this.connectionState;
+    }
+
+    /**
+     * Получение всех каналов (возвращает оригинальные имена без appKey)
+     */
+    getChannels() {
+      return Array.from(this.channels.values()).map(channel => 
+        channel.originalName || this.extractChannelName(channel.name)
+      );
+    }
+
+    /**
+     * Получение канала по имени
+     * @param {string} channelName - Имя канала (можно использовать оригинальное или полное)
+     * @returns {Channel|undefined} Объект канала
+     */
+    channel(channelName) {
+      const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+      return this.channels.get(fullChannelName);
+    }
+  }
+
+  var PushlerClient$1 = PushlerClient;
+
+  /**
+   * Серверный SDK для отправки сообщений через Pushler.ru API
+   * Используется на сервере Node.js для отправки событий в каналы
+   */
+  class PushlerServer {
+    /**
+     * @param {Object} options - Параметры клиента
+     * @param {string} options.appKey - Ключ приложения (key_xxx)
+     * @param {string} options.appSecret - Секрет приложения (secret_xxx)
+     * @param {string} [options.apiUrl='http://localhost:8000/api'] - URL API сервера
+     * @param {number} [options.timeout=30000] - Таймаут запроса в мс
+     */
+    constructor(options = {}) {
+      if (!options.appKey) {
+        throw new Error('appKey is required');
+      }
+      if (!options.appSecret) {
+        throw new Error('appSecret is required');
+      }
+
+      this.appKey = options.appKey;
+      this.appSecret = options.appSecret;
+      this.apiUrl = (options.apiUrl || 'http://localhost:8000/api').replace(/\/$/, '');
+      this.timeout = options.timeout || 30000;
+    }
+
+    /**
+     * Формирование полного имени канала с префиксом appKey
+     * Формат: {appKey}:{channelName}
+     * @param {string} channelName - Оригинальное имя канала
+     * @returns {string} Полное имя канала
+     */
+    formatChannelName(channelName) {
+      // Если канал уже содержит appKey, возвращаем как есть
+      if (channelName.startsWith(this.appKey + ':')) {
+        return channelName;
+      }
+      return `${this.appKey}:${channelName}`;
+    }
+
+    /**
+     * Извлечение оригинального имени канала (без appKey)
+     * @param {string} fullChannelName - Полное имя канала
+     * @returns {string} Оригинальное имя канала
+     */
+    extractChannelName(fullChannelName) {
+      const prefix = this.appKey + ':';
+      if (fullChannelName.startsWith(prefix)) {
+        return fullChannelName.substring(prefix.length);
+      }
+      return fullChannelName;
+    }
+
+    /**
+     * Генерация подписи для API запроса
+     * 
+     * @param {string} body - JSON тело запроса
+     * @param {number} timestamp - Unix timestamp
+     * @returns {string} HMAC-SHA256 подпись
+     */
+    generateApiSignature(body, timestamp) {
+      const signatureString = body + timestamp;
+      return crypto.createHmac('sha256', this.appSecret)
+        .update(signatureString)
+        .digest('hex');
+    }
+
+    /**
+     * Генерация подписи для авторизации канала
+     * 
+     * @param {string} channelName - Название канала (полное с appKey)
+     * @param {string} socketId - ID сокета
+     * @returns {string} HMAC-SHA256 подпись
+     */
+    generateChannelSignature(channelName, socketId) {
+      // Подпись генерируется для полного имени канала
+      const fullChannelName = this.formatChannelName(channelName);
+      const signatureString = socketId + ':' + fullChannelName;
+      return crypto.createHmac('sha256', this.appSecret)
+        .update(signatureString)
+        .digest('hex');
+    }
+
+    /**
+     * Авторизация приватного канала
+     * 
+     * @param {string} channelName - Название канала (appKey будет добавлен автоматически)
+     * @param {string} socketId - ID сокета
+     * @returns {Object} Результат авторизации с полным именем канала
+     */
+    authorizeChannel(channelName, socketId) {
+      const fullChannelName = this.formatChannelName(channelName);
+      const signature = this.generateChannelSignature(fullChannelName, socketId);
+      return {
+        auth: this.appKey + ':' + signature,
+        channel: fullChannelName
+      };
+    }
+
+    /**
+     * Авторизация presence канала
+     * 
+     * @param {string} channelName - Название канала (appKey будет добавлен автоматически)
+     * @param {string} socketId - ID сокета
+     * @param {Object} userData - Данные пользователя
+     * @param {string|number} userData.user_id - ID пользователя (обязательно)
+     * @param {Object} [userData.user_info] - Дополнительная информация о пользователе
+     * @returns {Object} Результат авторизации с полным именем канала
+     */
+    authorizePresenceChannel(channelName, socketId, userData) {
+      if (!userData || !userData.user_id) {
+        throw new Error('user_id is required for presence channels');
+      }
+
+      const fullChannelName = this.formatChannelName(channelName);
+      const signature = this.generateChannelSignature(fullChannelName, socketId);
+      
+      return {
+        auth: this.appKey + ':' + signature,
+        channel: fullChannelName,
+        channel_data: JSON.stringify({
+          user_id: userData.user_id,
+          user_info: userData.user_info || {}
+        })
+      };
+    }
+
+    /**
+     * Аутентификация пользователя для WebSocket соединения
+     * 
+     * @param {string} socketId - ID сокета
+     * @param {Object} userData - Данные пользователя
+     * @returns {Object} Результат аутентификации
+     */
+    authenticateUser(socketId, userData) {
+      if (!userData || !userData.user_id) {
+        throw new Error('user_id is required for user authentication');
+      }
+
+      const signature = this.generateChannelSignature('user-' + userData.user_id, socketId);
+      
+      return {
+        auth: this.appKey + ':' + signature,
+        user_data: JSON.stringify(userData)
+      };
+    }
+
+    /**
+     * Отправка события в канал
+     * 
+     * @param {string|string[]} channels - Канал или массив каналов (appKey будет добавлен автоматически)
+     * @param {string} event - Название события
+     * @param {Object} data - Данные события
+     * @param {string} [socketId] - ID сокета (для исключения отправителя)
+     * @returns {Promise<Object>} Результат отправки
+     */
+    async trigger(channels, event, data, socketId = null) {
+      const channelList = Array.isArray(channels) ? channels : [channels];
+      
+      // Добавляем appKey ко всем каналам
+      const formattedChannels = channelList.map(ch => this.formatChannelName(ch));
+      
+      // Для одного канала используем /messages/send
+      if (formattedChannels.length === 1) {
+        const payload = {
+          channel: formattedChannels[0],
+          event,
+          data
+        };
+
+        if (socketId) {
+          payload.socket_id = socketId;
+        }
+
+        return this.makeSignedRequest('POST', '/messages/send', payload);
+      }
+      
+      // Для нескольких каналов используем /messages/broadcast
+      const payload = {
+        channels: formattedChannels,
+        event,
+        data
+      };
+
+      if (socketId) {
+        payload.socket_id = socketId;
+      }
+
+      return this.makeSignedRequest('POST', '/messages/broadcast', payload);
+    }
+
+    /**
+     * Отправка события в несколько каналов одновременно
+     * 
+     * @param {string[]} channels - Массив каналов
+     * @param {string} event - Название события
+     * @param {Object} data - Данные события
+     * @param {string} [socketId] - ID сокета (для исключения отправителя)
+     * @returns {Promise<Object>} Результат отправки
+     */
+    async triggerBatch(channels, event, data, socketId = null) {
+      return this.trigger(channels, event, data, socketId);
+    }
+
+    /**
+     * Получение статуса сообщения
+     * 
+     * @param {string|number} messageId - ID сообщения
+     * @returns {Promise<Object>} Статус сообщения
+     */
+    async getMessageStatus(messageId) {
+      return this.makeSignedRequest('GET', `/messages/${messageId}/status`);
+    }
+
+    /**
+     * Получение списка сообщений
+     * 
+     * @param {Object} [params] - Параметры запроса
+     * @param {string} [params.status] - Фильтр по статусу
+     * @param {number} [params.per_page] - Количество на страницу
+     * @returns {Promise<Object>} Список сообщений
+     */
+    async getMessages(params = {}) {
+      const query = new URLSearchParams(params).toString();
+      const endpoint = '/messages' + (query ? '?' + query : '');
+      return this.makeSignedRequest('GET', endpoint);
+    }
+
+    /**
+     * Проверка валидности приложения
+     * 
+     * @returns {Promise<Object>} Информация о приложении
+     */
+    async validateApplication() {
+      const response = await this.makeHttpRequest('GET', `/applications/validate/${this.appKey}`);
+      
+      if (!response.id) {
+        throw new Error(response.error || 'Application validation failed');
+      }
+
+      return response;
+    }
+
+    /**
+     * Получение информации о приложении
+     * 
+     * @returns {Promise<Object>} Информация о приложении
+     */
+    async getApplicationInfo() {
+      return this.validateApplication();
+    }
+
+    /**
+     * Валидация вебхука
+     * 
+     * @param {Object} headers - Заголовки запроса
+     * @param {string} body - Тело запроса
+     * @returns {Object} Данные вебхука
+     * @throws {Error} При невалидной подписи
+     */
+    verifyWebhook(headers, body) {
+      const signature = headers['X-Pushler-Signature'] || headers['x-pushler-signature'] || '';
+      
+      if (!signature) {
+        throw new Error('Missing X-Pushler-Signature header');
+      }
+
+      const expectedSignature = 'sha256=' + crypto.createHmac('sha256', this.appSecret)
+        .update(body)
+        .digest('hex');
+      
+      // Timing-safe сравнение
+      if (!this.timingSafeEqual(expectedSignature, signature)) {
+        throw new Error('Invalid webhook signature');
+      }
+
+      const data = JSON.parse(body);
+      return data;
+    }
+
+    /**
+     * Timing-safe сравнение строк
+     * @private
+     */
+    timingSafeEqual(a, b) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      
+      let result = 0;
+      for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+      }
+      return result === 0;
+    }
+
+    /**
+     * Выполнение подписанного HTTP запроса
+     * 
+     * @private
+     * @param {string} method - HTTP метод
+     * @param {string} endpoint - API endpoint
+     * @param {Object} [data] - Данные запроса
+     * @returns {Promise<Object>} Результат запроса
+     */
+    async makeSignedRequest(method, endpoint, data = null) {
+      const url = this.apiUrl + endpoint;
+      const timestamp = Math.floor(Date.now() / 1000);
+      const body = data ? JSON.stringify(data) : '';
+      const signature = this.generateApiSignature(body, timestamp);
+      
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': 'PushlerRu-JS-SDK/1.0.0',
+        'X-Pushler-Key': this.appKey,
+        'X-Pushler-Signature': signature,
+        'X-Pushler-Timestamp': String(timestamp)
+      };
+
+      const options = {
+        method,
+        headers,
+        signal: AbortSignal.timeout(this.timeout)
+      };
+
+      if (method === 'POST' && body) {
+        options.body = body;
+      }
+
+      const response = await fetch(url, options);
+      const result = await response.json();
+
+      if (!response.ok) {
+        const message = result.message || `HTTP request failed with status: ${response.status}`;
+        const error = new Error(message);
+        error.statusCode = response.status;
+        error.response = result;
+        throw error;
+      }
+
+      return result;
+    }
+
+    /**
+     * Выполнение обычного HTTP запроса (без подписи)
+     * 
+     * @private
+     * @param {string} method - HTTP метод
+     * @param {string} endpoint - API endpoint
+     * @param {Object} [data] - Данные запроса
+     * @returns {Promise<Object>} Результат запроса
+     */
+    async makeHttpRequest(method, endpoint, data = null) {
+      const url = this.apiUrl + endpoint;
+      
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': 'PushlerRu-JS-SDK/1.0.0'
+      };
+
+      const options = {
+        method,
+        headers,
+        signal: AbortSignal.timeout(this.timeout)
+      };
+
+      if (method === 'POST' && data) {
+        options.body = JSON.stringify(data);
+      }
+
+      const response = await fetch(url, options);
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(`HTTP request failed with status: ${response.status}`);
+      }
+
+      return result;
+    }
+
+    /**
+     * Получение App Key
+     * @returns {string}
+     */
+    getAppKey() {
+      return this.appKey;
+    }
+
+    /**
+     * Получение API URL
+     * @returns {string}
+     */
+    getApiUrl() {
+      return this.apiUrl;
+    }
+  }
+
+  var PushlerServer$1 = PushlerServer;
+
+  /**
+   * Валидация данных канала
+   * @param {string} channelName - Название канала
+   * @param {string} channelType - Тип канала
+   * @param {Object} options - Опции канала
+   * @returns {Object} - Результат валидации
+   */
+
+  /**
+   * Генерация уникального ID сокета
+   * @returns {string} - Уникальный ID сокета
+   */
+  function generateSocketId() {
+    return Math.random().toString(36).substr(2, 9) + '.' + Math.floor(Math.random() * 1000000);
+  }
+
+  // Создаем объект с методами для удобного API
+  const Pushler = {
+    // Клиентский SDK для браузера (WebSocket)
+    CreateClient: (options) => new PushlerClient$1(options),
+    Create: (options) => new PushlerClient$1(options), // Алиас для краткости
+    
+    // Серверный SDK для Node.js (отправка сообщений через API)
+    CreateServer: (options) => new PushlerServer$1(options),
+    Server: (options) => new PushlerServer$1(options), // Алиас для краткости
+    
+    Channel: Channel$1,
+    ChannelTypes,
+    ConnectionStates,
+    generateSocketId
+  };
+
+  exports.Channel = Channel$1;
+  exports.ChannelTypes = ChannelTypes;
+  exports.ConnectionStates = ConnectionStates;
+  exports.Pushler = Pushler;
+  exports.PushlerClient = PushlerClient$1;
+  exports.PushlerServer = PushlerServer$1;
+  exports.default = Pushler;
+  exports.generateSocketId = generateSocketId;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+
+// Устанавливаем Pushler как сам объект для удобного API
+if (typeof window !== "undefined" && window.Pushler && window.Pushler.Pushler) {
+  window.Pushler = window.Pushler.Pushler;
+}
+//# sourceMappingURL=pushler-ru.js.map