larasopp 1.2.24 → 1.2.26

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 Sergey Serov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 Sergey Serov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,443 +1,443 @@
-# Larasopp Client
-
-WebSocket client for Laravel with full TypeScript support and type safety.
-
-## Features
-
-- 🔌 **WebSocket Connection** - Real-time bidirectional communication
-- 🎯 **Full TypeScript Support** - Complete type safety for channels, events, and users
-- 📡 **Channel Subscriptions** - Subscribe to multiple channels
-- 🎧 **Event Listeners** - Listen to specific events with typed callbacks
-- 👥 **Presence Channels** - Track users joining/leaving channels
-- 🔐 **Authentication** - Token-based authentication
-- 🔄 **Auto Reconnect** - Automatic reconnection with configurable delays
-- ✅ **Type Safety** - Compile-time type checking for all operations
-
-## Installation
-
-```bash
-npm install larasopp
-# or
-yarn add larasopp
-# or
-pnpm add larasopp
-```
-
-## Related Packages
-
-- **Server**: [larasopp-server](https://www.npmjs.com/package/larasopp-server)
-- **Laravel Package**: `composer require larasopp/larasopp`
-
-## Quick Start
-
-```typescript
-import Larasopp from 'larasopp';
-
-const larasopp = new Larasopp({
-  host: 'ws://127.0.0.1:3001',
-  token: 'your-auth-token'
-});
-
-larasopp.connect();
-```
-
-## TypeScript Support
-
-Larasopp provides full TypeScript support with generic types for channels, events, and users.
-
-### Defining Types
-
-```typescript
-// Define your channel events structure
-type ChannelsEvents = {
-  chat: {
-    message: { text: string; author: string; timestamp: number };
-    typing: { user: string };
-    userJoined: { user: string };
-  };
-  notifications: {
-    alert: { title: string; body: string; type: 'info' | 'warning' | 'error' };
-    update: { version: string };
-  };
-};
-
-// Define your user type
-interface MyUser {
-  id: number;
-  name: string;
-  email: string;
-  avatar?: string;
-}
-
-// Create typed instance
-const larasopp = new Larasopp<ChannelsEvents, MyUser>({
-  host: 'ws://127.0.0.1:3001',
-  token: 'your-token'
-});
-```
-
-## API Reference
-
-### Configuration
-
-```typescript
-interface IConfig {
-  host: string;                    // WebSocket server URL
-  token?: string;                  // Authentication token
-  reviver?: (key: string, value: any) => any;  // JSON reviver function
-  dataReviver?: { [key: string]: (value: any) => any };  // Per-key revivers
-  reconnect?: number;              // Max reconnection attempts
-  reconnectDelay?: number;         // Delay between reconnections (ms)
-}
-```
-
-### Connection
-
-#### `connect(token?: string)`
-
-Connect to the WebSocket server.
-
-```typescript
-larasopp.connect();
-// or with token
-larasopp.connect('new-token');
-```
-
-#### `disconnect()`
-
-Disconnect from the WebSocket server.
-
-```typescript
-larasopp.disconnect();
-```
-
-#### `setToken(token: string)`
-
-Update authentication token.
-
-```typescript
-larasopp.setToken('new-token');
-```
-
-### Channels
-
-#### `subscribe<K>(channel: K): Listener`
-
-Subscribe to a channel. Returns a `Listener` instance for the channel.
-
-```typescript
-// TypeScript will enforce that 'chat' exists in ChannelsEvents
-const listener = larasopp.subscribe('chat');
-```
-
-#### `unsubscribe<K>(channel: K)`
-
-Unsubscribe from a channel.
-
-```typescript
-larasopp.unsubscribe('chat');
-```
-
-#### `countListeners<K>(channel: K): number`
-
-Get the number of listeners for a channel.
-
-```typescript
-const count = larasopp.countListeners('chat');
-```
-
-### Events
-
-#### `listen<K>(event: K, callback, withCache?: boolean): this`
-
-Listen to a specific event on the subscribed channel.
-
-```typescript
-const listener = larasopp.subscribe('chat');
-
-// TypeScript knows 'message' exists and its data type
-listener.listen('message', (data) => {
-  // data is typed as { text: string; author: string; timestamp: number }
-  console.log(data.text, data.author);
-});
-
-// withCache: true will call callback immediately if cached data exists
-listener.listen('typing', (data) => {
-  console.log(data.user, 'is typing');
-}, true);
-```
-
-#### `trigger<K, E>(channel: K, event: E, message, permission?, waitSubscribe?): void`
-
-Trigger an event on a channel.
-
-**Permission Levels:**
-
-- **`'public'`** - Event will be sent to all channel subscribers AND to the API application
-- **`'protected'`** - Event will be sent to all channel subscribers but NOT to the API application
-- **`'private'`** - Event will be sent ONLY to the API application, not to channel subscribers
-
-```typescript
-// TypeScript ensures 'chat' channel and 'message' event exist
-// and that the message matches the event type
-
-// Public: sent to all subscribers and API
-larasopp.trigger('chat', 'message', {
-  text: 'Hello World',
-  author: 'John Doe',
-  timestamp: Date.now()
-}, 'public');
-
-// Protected: sent to subscribers only, not to API
-larasopp.trigger('chat', 'message', {
-  text: 'User message',
-  author: 'Jane Doe',
-  timestamp: Date.now()
-}, 'protected');
-
-// Private: sent to API only, not to subscribers
-larasopp.trigger('chat', 'message', {
-  text: 'Admin notification',
-  author: 'System',
-  timestamp: Date.now()
-}, 'private', true); // waitSubscribe: true waits for subscription
-```
-
-### Event Permissions
-
-When triggering events, you can specify one of three permission levels:
-
-| Permission | Channel Subscribers | API Application | Use Case |
-|------------|---------------------|-----------------|----------|
-| `'public'` | ✅ Yes | ✅ Yes | Broadcast to everyone including server-side processing |
-| `'protected'` | ✅ Yes | ❌ No | Client-to-client communication without server handling |
-| `'private'` | ❌ No | ✅ Yes | Server-side only events (notifications, admin actions) |
-
-**Examples:**
-
-```typescript
-// Public: Broadcast message to all users and process on server
-larasopp.trigger('chat', 'message', {
-  text: 'Hello everyone!',
-  author: 'John'
-}, 'public');
-
-// Protected: Send to users but don't trigger server-side handlers
-larasopp.trigger('chat', 'typing', {
-  user: 'John'
-}, 'protected');
-
-// Private: Server-side only (e.g., admin notifications, system events)
-larasopp.trigger('notifications', 'alert', {
-  title: 'System Maintenance',
-  body: 'Scheduled maintenance in 5 minutes'
-}, 'private');
-```
-
-### Presence Channels
-
-#### `here(callback, withCache?: boolean): this`
-
-Get list of users currently in the channel.
-
-```typescript
-listener.here((users) => {
-  // users is typed as MyUser[]
-  users.forEach(user => {
-    console.log(user.name, 'is here');
-  });
-});
-```
-
-#### `joining(callback, withCache?: boolean): this`
-
-Listen for users joining the channel.
-
-```typescript
-listener.joining((user) => {
-  // user is typed as MyUser
-  console.log(user.name, 'joined');
-});
-```
-
-#### `leaving(callback, withCache?: boolean): this`
-
-Listen for users leaving the channel.
-
-```typescript
-listener.leaving((user) => {
-  // user is typed as MyUser
-  console.log(user.name, 'left');
-});
-```
-
-### User Management
-
-#### `user(callback): void`
-
-Get current authenticated user.
-
-```typescript
-larasopp.user((user) => {
-  // user is typed as MyUser
-  console.log('Current user:', user.name);
-});
-```
-
-#### `userRefresh(callback): void`
-
-Refresh current user data.
-
-```typescript
-larasopp.userRefresh((user) => {
-  // user is typed as MyUser
-  console.log('Refreshed user:', user);
-});
-```
-
-### Socket Events
-
-#### `addListener(event, callback): EventListener | undefined`
-
-Listen to socket-level events: `'open'`, `'close'`, `'error'`.
-
-```typescript
-larasopp.addListener('open', () => {
-  console.log('Connected to WebSocket');
-});
-
-larasopp.addListener('close', () => {
-  console.log('Disconnected from WebSocket');
-});
-
-larasopp.addListener('error', (error) => {
-  console.error('WebSocket error:', error);
-});
-```
-
-### Listener Management
-
-#### `remove()`
-
-Remove all event listeners from a channel subscription.
-
-```typescript
-const listener = larasopp.subscribe('chat');
-listener.listen('message', handleMessage);
-
-// Later, remove all listeners
-listener.remove();
-```
-
-#### `unsubscribe()`
-
-Unsubscribe from the channel and remove all listeners.
-
-```typescript
-listener.unsubscribe();
-```
-
-## Complete Example
-
-```typescript
-import Larasopp from 'larasopp';
-
-// Define types
-type AppChannels = {
-  chat: {
-    message: { text: string; author: string };
-    typing: { user: string };
-  };
-  notifications: {
-    alert: { title: string; body: string };
-  };
-};
-
-interface AppUser {
-  id: number;
-  name: string;
-  email: string;
-}
-
-// Create instance
-const larasopp = new Larasopp<AppChannels, AppUser>({
-  host: 'ws://127.0.0.1:3001',
-  token: 'auth-token',
-  reconnect: 5,
-  reconnectDelay: 1000
-});
-
-// Connect
-larasopp.connect();
-
-// Listen to connection events
-larasopp.addListener('open', () => {
-  console.log('Connected');
-});
-
-// Subscribe to channel
-const chatListener = larasopp.subscribe('chat');
-
-// Listen to events with full type safety
-chatListener.listen('message', (data) => {
-  // TypeScript knows data structure
-  console.log(`${data.author}: ${data.text}`);
-});
-
-chatListener.listen('typing', (data) => {
-  console.log(`${data.user} is typing...`);
-});
-
-// Presence channel features
-chatListener.here((users) => {
-  console.log('Users in channel:', users.map(u => u.name));
-});
-
-chatListener.joining((user) => {
-  console.log(`${user.name} joined`);
-});
-
-chatListener.leaving((user) => {
-  console.log(`${user.name} left`);
-});
-
-// Trigger events
-larasopp.trigger('chat', 'message', {
-  text: 'Hello!',
-  author: 'John'
-}, 'public');
-
-// Get current user
-larasopp.user((user) => {
-  console.log('Logged in as:', user.name);
-});
-
-// Cleanup
-chatListener.remove();
-larasopp.unsubscribe('chat');
-larasopp.disconnect();
-```
-
-## Type Safety Benefits
-
-With TypeScript support, you get:
-
-- ✅ **Compile-time checks** - Catch errors before runtime
-- ✅ **Autocomplete** - IDE suggests available channels and events
-- ✅ **Type inference** - Automatic type detection for callbacks
-- ✅ **Refactoring safety** - Rename channels/events with confidence
-- ✅ **Documentation** - Types serve as inline documentation
-
-## License
-
-MIT
-
-## Author
-
-Sergey Serov
-
-## Links
-
-- [GitHub Repository](https://github.com/SergoMorello/larasopp.client)
-- [NPM Package](https://www.npmjs.com/package/larasopp)
-- [Server Package](https://www.npmjs.com/package/larasopp-server)
+# Larasopp Client
+
+WebSocket client for Laravel with full TypeScript support and type safety.
+
+## Features
+
+- 🔌 **WebSocket Connection** - Real-time bidirectional communication
+- 🎯 **Full TypeScript Support** - Complete type safety for channels, events, and users
+- 📡 **Channel Subscriptions** - Subscribe to multiple channels
+- 🎧 **Event Listeners** - Listen to specific events with typed callbacks
+- 👥 **Presence Channels** - Track users joining/leaving channels
+- 🔐 **Authentication** - Token-based authentication
+- 🔄 **Auto Reconnect** - Automatic reconnection with configurable delays
+- ✅ **Type Safety** - Compile-time type checking for all operations
+
+## Installation
+
+```bash
+npm install larasopp
+# or
+yarn add larasopp
+# or
+pnpm add larasopp
+```
+
+## Related Packages
+
+- **Server**: [larasopp-server](https://www.npmjs.com/package/larasopp-server)
+- **Laravel Package**: `composer require larasopp/larasopp`
+
+## Quick Start
+
+```typescript
+import Larasopp from 'larasopp';
+
+const larasopp = new Larasopp({
+  host: 'ws://127.0.0.1:3001',
+  token: 'your-auth-token'
+});
+
+larasopp.connect();
+```
+
+## TypeScript Support
+
+Larasopp provides full TypeScript support with generic types for channels, events, and users.
+
+### Defining Types
+
+```typescript
+// Define your channel events structure
+type ChannelsEvents = {
+  chat: {
+    message: { text: string; author: string; timestamp: number };
+    typing: { user: string };
+    userJoined: { user: string };
+  };
+  notifications: {
+    alert: { title: string; body: string; type: 'info' | 'warning' | 'error' };
+    update: { version: string };
+  };
+};
+
+// Define your user type
+interface MyUser {
+  id: number;
+  name: string;
+  email: string;
+  avatar?: string;
+}
+
+// Create typed instance
+const larasopp = new Larasopp<ChannelsEvents, MyUser>({
+  host: 'ws://127.0.0.1:3001',
+  token: 'your-token'
+});
+```
+
+## API Reference
+
+### Configuration
+
+```typescript
+interface IConfig {
+  host: string;                    // WebSocket server URL
+  token?: string;                  // Authentication token
+  reviver?: (key: string, value: any) => any;  // JSON reviver function
+  dataReviver?: { [key: string]: (value: any) => any };  // Per-key revivers
+  reconnect?: number;              // Max reconnection attempts
+  reconnectDelay?: number;         // Delay between reconnections (ms)
+}
+```
+
+### Connection
+
+#### `connect(token?: string)`
+
+Connect to the WebSocket server.
+
+```typescript
+larasopp.connect();
+// or with token
+larasopp.connect('new-token');
+```
+
+#### `disconnect()`
+
+Disconnect from the WebSocket server.
+
+```typescript
+larasopp.disconnect();
+```
+
+#### `setToken(token: string)`
+
+Update authentication token.
+
+```typescript
+larasopp.setToken('new-token');
+```
+
+### Channels
+
+#### `subscribe<K>(channel: K): Listener`
+
+Subscribe to a channel. Returns a `Listener` instance for the channel.
+
+```typescript
+// TypeScript will enforce that 'chat' exists in ChannelsEvents
+const listener = larasopp.subscribe('chat');
+```
+
+#### `unsubscribe<K>(channel: K)`
+
+Unsubscribe from a channel.
+
+```typescript
+larasopp.unsubscribe('chat');
+```
+
+#### `countListeners<K>(channel: K): number`
+
+Get the number of listeners for a channel.
+
+```typescript
+const count = larasopp.countListeners('chat');
+```
+
+### Events
+
+#### `listen<K>(event: K, callback, withCache?: boolean): this`
+
+Listen to a specific event on the subscribed channel.
+
+```typescript
+const listener = larasopp.subscribe('chat');
+
+// TypeScript knows 'message' exists and its data type
+listener.listen('message', (data) => {
+  // data is typed as { text: string; author: string; timestamp: number }
+  console.log(data.text, data.author);
+});
+
+// withCache: true will call callback immediately if cached data exists
+listener.listen('typing', (data) => {
+  console.log(data.user, 'is typing');
+}, true);
+```
+
+#### `trigger<K, E>(channel: K, event: E, message, permission?, waitSubscribe?): void`
+
+Trigger an event on a channel.
+
+**Permission Levels:**
+
+- **`'public'`** - Event will be sent to all channel subscribers AND to the API application
+- **`'protected'`** - Event will be sent to all channel subscribers but NOT to the API application
+- **`'private'`** - Event will be sent ONLY to the API application, not to channel subscribers
+
+```typescript
+// TypeScript ensures 'chat' channel and 'message' event exist
+// and that the message matches the event type
+
+// Public: sent to all subscribers and API
+larasopp.trigger('chat', 'message', {
+  text: 'Hello World',
+  author: 'John Doe',
+  timestamp: Date.now()
+}, 'public');
+
+// Protected: sent to subscribers only, not to API
+larasopp.trigger('chat', 'message', {
+  text: 'User message',
+  author: 'Jane Doe',
+  timestamp: Date.now()
+}, 'protected');
+
+// Private: sent to API only, not to subscribers
+larasopp.trigger('chat', 'message', {
+  text: 'Admin notification',
+  author: 'System',
+  timestamp: Date.now()
+}, 'private', true); // waitSubscribe: true waits for subscription
+```
+
+### Event Permissions
+
+When triggering events, you can specify one of three permission levels:
+
+| Permission | Channel Subscribers | API Application | Use Case |
+|------------|---------------------|-----------------|----------|
+| `'public'` | ✅ Yes | ✅ Yes | Broadcast to everyone including server-side processing |
+| `'protected'` | ✅ Yes | ❌ No | Client-to-client communication without server handling |
+| `'private'` | ❌ No | ✅ Yes | Server-side only events (notifications, admin actions) |
+
+**Examples:**
+
+```typescript
+// Public: Broadcast message to all users and process on server
+larasopp.trigger('chat', 'message', {
+  text: 'Hello everyone!',
+  author: 'John'
+}, 'public');
+
+// Protected: Send to users but don't trigger server-side handlers
+larasopp.trigger('chat', 'typing', {
+  user: 'John'
+}, 'protected');
+
+// Private: Server-side only (e.g., admin notifications, system events)
+larasopp.trigger('notifications', 'alert', {
+  title: 'System Maintenance',
+  body: 'Scheduled maintenance in 5 minutes'
+}, 'private');
+```
+
+### Presence Channels
+
+#### `here(callback, withCache?: boolean): this`
+
+Get list of users currently in the channel.
+
+```typescript
+listener.here((users) => {
+  // users is typed as MyUser[]
+  users.forEach(user => {
+    console.log(user.name, 'is here');
+  });
+});
+```
+
+#### `joining(callback, withCache?: boolean): this`
+
+Listen for users joining the channel.
+
+```typescript
+listener.joining((user) => {
+  // user is typed as MyUser
+  console.log(user.name, 'joined');
+});
+```
+
+#### `leaving(callback, withCache?: boolean): this`
+
+Listen for users leaving the channel.
+
+```typescript
+listener.leaving((user) => {
+  // user is typed as MyUser
+  console.log(user.name, 'left');
+});
+```
+
+### User Management
+
+#### `user(callback): void`
+
+Get current authenticated user.
+
+```typescript
+larasopp.user((user) => {
+  // user is typed as MyUser
+  console.log('Current user:', user.name);
+});
+```
+
+#### `userRefresh(callback): void`
+
+Refresh current user data.
+
+```typescript
+larasopp.userRefresh((user) => {
+  // user is typed as MyUser
+  console.log('Refreshed user:', user);
+});
+```
+
+### Socket Events
+
+#### `addListener(event, callback): EventListener | undefined`
+
+Listen to socket-level events: `'open'`, `'close'`, `'error'`.
+
+```typescript
+larasopp.addListener('open', () => {
+  console.log('Connected to WebSocket');
+});
+
+larasopp.addListener('close', () => {
+  console.log('Disconnected from WebSocket');
+});
+
+larasopp.addListener('error', (error) => {
+  console.error('WebSocket error:', error);
+});
+```
+
+### Listener Management
+
+#### `remove()`
+
+Remove all event listeners from a channel subscription.
+
+```typescript
+const listener = larasopp.subscribe('chat');
+listener.listen('message', handleMessage);
+
+// Later, remove all listeners
+listener.remove();
+```
+
+#### `unsubscribe()`
+
+Unsubscribe from the channel and remove all listeners.
+
+```typescript
+listener.unsubscribe();
+```
+
+## Complete Example
+
+```typescript
+import Larasopp from 'larasopp';
+
+// Define types
+type AppChannels = {
+  chat: {
+    message: { text: string; author: string };
+    typing: { user: string };
+  };
+  notifications: {
+    alert: { title: string; body: string };
+  };
+};
+
+interface AppUser {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// Create instance
+const larasopp = new Larasopp<AppChannels, AppUser>({
+  host: 'ws://127.0.0.1:3001',
+  token: 'auth-token',
+  reconnect: 5,
+  reconnectDelay: 1000
+});
+
+// Connect
+larasopp.connect();
+
+// Listen to connection events
+larasopp.addListener('open', () => {
+  console.log('Connected');
+});
+
+// Subscribe to channel
+const chatListener = larasopp.subscribe('chat');
+
+// Listen to events with full type safety
+chatListener.listen('message', (data) => {
+  // TypeScript knows data structure
+  console.log(`${data.author}: ${data.text}`);
+});
+
+chatListener.listen('typing', (data) => {
+  console.log(`${data.user} is typing...`);
+});
+
+// Presence channel features
+chatListener.here((users) => {
+  console.log('Users in channel:', users.map(u => u.name));
+});
+
+chatListener.joining((user) => {
+  console.log(`${user.name} joined`);
+});
+
+chatListener.leaving((user) => {
+  console.log(`${user.name} left`);
+});
+
+// Trigger events
+larasopp.trigger('chat', 'message', {
+  text: 'Hello!',
+  author: 'John'
+}, 'public');
+
+// Get current user
+larasopp.user((user) => {
+  console.log('Logged in as:', user.name);
+});
+
+// Cleanup
+chatListener.remove();
+larasopp.unsubscribe('chat');
+larasopp.disconnect();
+```
+
+## Type Safety Benefits
+
+With TypeScript support, you get:
+
+- ✅ **Compile-time checks** - Catch errors before runtime
+- ✅ **Autocomplete** - IDE suggests available channels and events
+- ✅ **Type inference** - Automatic type detection for callbacks
+- ✅ **Refactoring safety** - Rename channels/events with confidence
+- ✅ **Documentation** - Types serve as inline documentation
+
+## License
+
+MIT
+
+## Author
+
+Sergey Serov
+
+## Links
+
+- [GitHub Repository](https://github.com/SergoMorello/larasopp.client)
+- [NPM Package](https://www.npmjs.com/package/larasopp)
+- [Server Package](https://www.npmjs.com/package/larasopp-server)

package/lib/Core.d.ts

@@ -9,7 +9,9 @@ declare abstract class Core {
     private reconnectTimer?;
     constructor(config: IConfig);
     setConfig(config: IConfig): this;
+    getConfig(): IConfig;
     setToken(token: string): this;
+    getToken(): string | undefined;
     /**
      * Connect to websocket
      * @returns {this}

package/lib/Core.js

@@ -56,6 +56,9 @@ class Core {
         this.config = config;
         return this;
     }
+    getConfig() {
+        return this.config;
+    }
     setToken(token) {
         this.config = Object.assign(Object.assign({}, this.config), { token });
         if (this.status) {
@@ -65,6 +68,9 @@ class Core {
         }
         return this;
     }
+    getToken() {
+        return this.config.token;
+    }
     /**
      * Connect to websocket
      * @returns {this}
@@ -72,6 +78,9 @@ class Core {
     connect(token) {
         if (this.status)
             return this;
+        if (this.config.debug) {
+            console.log('ws_connect');
+        }
         try {
             if (token)
                 this.setToken(token);
@@ -95,6 +104,9 @@ class Core {
      */
     disconnect() {
         var _a;
+        if (this.config.debug) {
+            console.log('ws_disconnect');
+        }
         if (this.status) {
             (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
         }
@@ -111,6 +123,9 @@ class Core {
     }
     tryReconnect() {
         var _a;
+        if (this.config.debug) {
+            console.log('ws_try_reconnect', this.reconnectTimer);
+        }
         if (this.reconnectTimer)
             clearTimeout(this.reconnectTimer);
         this.reconnectTimer = setTimeout(() => {
@@ -127,13 +142,22 @@ class Core {
         }, (_a = this.config.reconnectDelay) !== null && _a !== void 0 ? _a : 1000);
     }
     handleOpen(e) {
+        if (this.config.debug) {
+            console.log('ws_open', e);
+        }
         this.events.emit("open", e);
     }
     handleClose(e) {
+        if (this.config.debug) {
+            console.log('ws_close', e);
+        }
         this.events.emit("close", e);
         this.tryReconnect();
     }
     handleError(e) {
+        if (this.config.debug) {
+            console.log('ws_error', e);
+        }
         this.events.emit("error", e);
     }
     jsonParse(str) {
@@ -157,6 +181,9 @@ class Core {
         return JSON.parse(str);
     }
     handleMessage(e) {
+        if (this.config.debug) {
+            console.log('ws_message', e.data);
+        }
         if (this.isJson(e.data)) {
             const json = this.jsonParse(e.data);
             if (json.socket_id) {

package/lib/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const SocketEvents: readonly ["open", "close", "error"];
+export declare const SocketEvents: readonly ["open", "close", "error", "ready"];
 export declare const ListenerEvents: readonly ["subscribe", "unsubscribe"];

package/lib/constants.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListenerEvents = exports.SocketEvents = void 0;
-exports.SocketEvents = ['open', 'close', 'error'];
+exports.SocketEvents = ['open', 'close', 'error', 'ready'];
 exports.ListenerEvents = ['subscribe', 'unsubscribe'];

package/lib/index.js

@@ -20,9 +20,12 @@ class Larasopp extends Core_1.default {
     }
     listenResumeSubscribes() {
         this.addListener('open', () => {
-            Object.keys(this.channels).forEach((channel) => this.send({
-                subscribe: channel
-            }));
+            this.user(() => {
+                Object.keys(this.channels).forEach((channel) => this.send({
+                    subscribe: channel
+                }));
+                this.events.emit('ready', true);
+            });
         });
     }
     user(callback) {

package/lib/types.d.ts

@@ -26,6 +26,7 @@ export interface IConfig {
     dataReviver?: TConfigDataReviver;
     reconnect?: number;
     reconnectDelay?: number;
+    debug?: boolean;
 }
 export type TUser = {
     id: string | number;

package/package.json

@@ -1,67 +1,67 @@
-{
-  "name": "larasopp",
-  "version": "1.2.24",
-  "description": "Websocket client for laravel",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "scripts": {
-    "test": "jest",
-    "build": "tsc",
-    "prepublishOnly": "npm run test && npm run build"
-  },
-  "files": [
-    "lib"
-  ],
-  "jest": {
-    "transform": {
-      "^.+\\.[t|j]sx?$": "babel-jest"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/SergoMorello/larasopp.client.git"
-  },
-  "keywords": [
-    "websocket",
-    "websocket-client",
-    "laravel",
-    "laravel-broadcast",
-    "broadcast",
-    "events",
-    "typescript",
-    "types",
-    "type-safe",
-    "type-safety",
-    "typing",
-    "real-time",
-    "realtime",
-    "presence",
-    "channels",
-    "client",
-    "socket",
-    "ws",
-    "event-emitter",
-    "subscription",
-    "reconnect",
-    "authentication",
-    "token",
-    "pubsub",
-    "publish-subscribe"
-  ],
-  "author": "Sergey Serov",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/SergoMorello/larasopp.client/issues"
-  },
-  "homepage": "https://github.com/SergoMorello/larasopp.client#readme",
-  "devDependencies": {
-    "@babel/preset-env": "^7.22.9",
-    "@types/jest": "^29.5.3",
-    "babel-jest": "^29.4.3",
-    "jest": "^29.4.3",
-    "typescript": "^5.1.6"
-  },
-  "dependencies": {
-    "easy-event-emitter": "^1.1.5"
-  }
-}
+{
+  "name": "larasopp",
+  "version": "1.2.26",
+  "description": "Websocket client for laravel",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "build": "tsc",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "files": [
+    "lib"
+  ],
+  "jest": {
+    "transform": {
+      "^.+\\.[t|j]sx?$": "babel-jest"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SergoMorello/larasopp.client.git"
+  },
+  "keywords": [
+    "websocket",
+    "websocket-client",
+    "laravel",
+    "laravel-broadcast",
+    "broadcast",
+    "events",
+    "typescript",
+    "types",
+    "type-safe",
+    "type-safety",
+    "typing",
+    "real-time",
+    "realtime",
+    "presence",
+    "channels",
+    "client",
+    "socket",
+    "ws",
+    "event-emitter",
+    "subscription",
+    "reconnect",
+    "authentication",
+    "token",
+    "pubsub",
+    "publish-subscribe"
+  ],
+  "author": "Sergey Serov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/SergoMorello/larasopp.client/issues"
+  },
+  "homepage": "https://github.com/SergoMorello/larasopp.client#readme",
+  "devDependencies": {
+    "@babel/preset-env": "^7.22.9",
+    "@types/jest": "^29.5.3",
+    "babel-jest": "^29.4.3",
+    "jest": "^29.4.3",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "easy-event-emitter": "^1.2.3"
+  }
+}