larasopp 1.2.9 → 1.2.11

package/lib/Core.d.ts

@@ -1,42 +1,11 @@
 import { type Events } from "easy-event-emitter";
-import type Listener from "./Listener";
-export declare const SocketEvents: readonly ["open", "close", "error"];
-export type TSocketEvents = typeof SocketEvents[number];
-export declare const ListenerEvents: readonly ["subscribe", "unsubscribe"];
-export type TListenerEvents = typeof ListenerEvents[number];
-export type TListenerCallback = (data: {
-    channel: string;
-}) => void;
-export type TPermissions = 'public' | 'protected' | 'private';
-export type TListen = {
-    remove: () => void;
-};
-export type TMessage<T> = {
-    subscribe?: string;
-    unsubscribe?: string;
-    channel?: string;
-    event?: string;
-    token?: string;
-    message?: T;
-    type?: TPermissions;
-};
-export type TConfigDataReviver = {
-    [index: string]: (value: any) => any;
-};
-export interface IConfig {
-    host: string;
-    token?: string;
-    reviver?: (this: any, key: string, value: any) => any;
-    dataReviver?: TConfigDataReviver;
-}
-export type TChannels = {
-    [channel: string]: Listener[];
-};
+import type { IConfig, TMessage } from "./types";
 declare abstract class Core {
     readonly events: Events;
     private ws?;
     private _socketId?;
     private config;
+    private reconnectCount;
     constructor(config: IConfig);
     setConfig(config: IConfig): void;
     setToken(token: string): void;
@@ -51,6 +20,7 @@ declare abstract class Core {
      */
     disconnect(): void;
     protected isJson(str: string): boolean;
+    private tryReconnect;
     private handleOpen;
     private handleClose;
     private handleError;

package/lib/Core.js

@@ -3,10 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListenerEvents = exports.SocketEvents = void 0;
 const easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
-exports.SocketEvents = ['open', 'close', 'error'];
-exports.ListenerEvents = ['subscribe', 'unsubscribe'];
+const constants_1 = require("./constants");
 class Core {
     constructor(config) {
         Object.defineProperty(this, "events", {
@@ -33,7 +31,14 @@ class Core {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "reconnectCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.events = new easy_event_emitter_1.default;
+        this.reconnectCount = 0;
         this.config = config;
         this.handleOpen = this.handleOpen.bind(this);
         this.handleClose = this.handleClose.bind(this);
@@ -91,11 +96,24 @@ class Core {
         }
         return true;
     }
+    tryReconnect() {
+        var _a, _b;
+        if (typeof this.config.reconnect === 'undefined' ||
+            this.reconnectCount >= this.config.reconnect ||
+            typeof this.ws === 'undefined' ||
+            this.status ||
+            ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === this.ws.CONNECTING)
+            return;
+        ++this.reconnectCount;
+        this.connect();
+        setTimeout(() => this.tryReconnect(), (_b = this.config.reconnectDelay) !== null && _b !== void 0 ? _b : 1000);
+    }
     handleOpen(e) {
         this.events.emit("open", e);
     }
     handleClose(e) {
         this.events.emit("close", e);
+        this.tryReconnect();
     }
     handleError(e) {
         this.events.emit("error", e);
@@ -132,7 +150,7 @@ class Core {
         }
     }
     emitListener(method, channel) {
-        if (exports.ListenerEvents.includes(method)) {
+        if (constants_1.ListenerEvents.includes(method)) {
             this.events.emit(method + ':' + channel, {
                 channel
             });

package/lib/Listener.d.ts

@@ -1,11 +1,12 @@
-import { type Event } from "easy-event-emitter";
+import { type Event as EventListener } from "easy-event-emitter";
 import type Larasopp from ".";
 declare class Listener {
     private readonly context;
     private channel;
     private listeners?;
     constructor(channel: string, constext: Larasopp);
-    listen(event: string, callback: (data: any) => void): Event;
+    listen(event: string, callback: (data: any) => void): EventListener;
+    unsubscribe(): void;
     remove(): void;
 }
 export default Listener;

package/lib/Listener.js

@@ -31,6 +31,10 @@ class Listener {
         this.listeners.push(listener);
         return listener;
     }
+    unsubscribe() {
+        this.context.unsubscribe(this.channel);
+        this.remove();
+    }
     remove() {
         if (!this.listeners)
             return;

package/lib/Subscribe.d.ts

@@ -1,29 +1,29 @@
-import { TMessage, TListenerEvents, TListenerCallback, TListen } from "./Core";
-import type { Event, Events } from "easy-event-emitter";
-interface ISubscribe {
-    events: Events;
-    hasChannel: (channel: string) => boolean;
-    pushChannel: (channel: string) => void;
-    removeChannel: (channel: string) => void;
-    send: <T>(message: TMessage<T>) => void;
-    channel: string;
-    status: boolean;
-}
-declare class Subscribe {
-    private events;
-    private currentEvents;
-    private hasChannel;
-    private pushChannel;
-    private removeChannel;
-    private status;
-    private _channel;
-    private send;
-    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }: ISubscribe);
-    get channel(): string;
-    private init;
-    listen<T>(event: string, callback: (data: T) => void): TListen;
-    private clearEvents;
-    remove(): void;
-    addListener(event: TListenerEvents, callback: TListenerCallback): Event | undefined;
-}
-export default Subscribe;
+import { TMessage, TListenerEvents, TListenerCallback, TListen } from "./Core";
+import type { Event, Events } from "easy-event-emitter";
+interface ISubscribe {
+    events: Events;
+    hasChannel: (channel: string) => boolean;
+    pushChannel: (channel: string) => void;
+    removeChannel: (channel: string) => void;
+    send: <T>(message: TMessage<T>) => void;
+    channel: string;
+    status: boolean;
+}
+declare class Subscribe {
+    private events;
+    private currentEvents;
+    private hasChannel;
+    private pushChannel;
+    private removeChannel;
+    private status;
+    private _channel;
+    private send;
+    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }: ISubscribe);
+    get channel(): string;
+    private init;
+    listen<T>(event: string, callback: (data: T) => void): TListen;
+    private clearEvents;
+    remove(): void;
+    addListener(event: TListenerEvents, callback: TListenerCallback): Event | undefined;
+}
+export default Subscribe;

package/lib/Subscribe.js

@@ -1,107 +1,107 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Subscribe {
-    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }) {
-        Object.defineProperty(this, "events", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "currentEvents", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "hasChannel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "pushChannel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "removeChannel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_channel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "send", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.events = events;
-        this.currentEvents = [];
-        this.hasChannel = hasChannel;
-        this.pushChannel = pushChannel;
-        this.removeChannel = removeChannel;
-        this.status = status;
-        this._channel = channel;
-        this.send = send;
-        this.init();
-    }
-    get channel() {
-        return this._channel;
-    }
-    init() {
-        this.pushChannel(this.channel);
-        if (this.status) {
-            this.send({
-                subscribe: this.channel
-            });
-        }
-        else {
-            const event = this.events.addListener('open', () => {
-                this.send({
-                    subscribe: this.channel
-                });
-                event.remove();
-            });
-        }
-    }
-    listen(event, callback) {
-        const Event = this.events.addListener(this.channel + ':' + event, callback);
-        this.currentEvents.push(Event);
-        return {
-            remove: () => {
-                Event.remove();
-            }
-        };
-    }
-    clearEvents() {
-        this.currentEvents.forEach((event) => event.remove());
-    }
-    remove() {
-        this.clearEvents();
-        this.removeChannel(this.channel);
-        if (this.hasChannel(this.channel))
-            return;
-        this.send({
-            unsubscribe: this.channel
-        });
-    }
-    addListener(event, callback) {
-        return this.events.addListener(event + ':' + this.channel, callback);
-    }
-}
-exports.default = Subscribe;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Subscribe {
+    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }) {
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hasChannel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pushChannel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "removeChannel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "send", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.events = events;
+        this.currentEvents = [];
+        this.hasChannel = hasChannel;
+        this.pushChannel = pushChannel;
+        this.removeChannel = removeChannel;
+        this.status = status;
+        this._channel = channel;
+        this.send = send;
+        this.init();
+    }
+    get channel() {
+        return this._channel;
+    }
+    init() {
+        this.pushChannel(this.channel);
+        if (this.status) {
+            this.send({
+                subscribe: this.channel
+            });
+        }
+        else {
+            const event = this.events.addListener('open', () => {
+                this.send({
+                    subscribe: this.channel
+                });
+                event.remove();
+            });
+        }
+    }
+    listen(event, callback) {
+        const Event = this.events.addListener(this.channel + ':' + event, callback);
+        this.currentEvents.push(Event);
+        return {
+            remove: () => {
+                Event.remove();
+            }
+        };
+    }
+    clearEvents() {
+        this.currentEvents.forEach((event) => event.remove());
+    }
+    remove() {
+        this.clearEvents();
+        this.removeChannel(this.channel);
+        if (this.hasChannel(this.channel))
+            return;
+        this.send({
+            unsubscribe: this.channel
+        });
+    }
+    addListener(event, callback) {
+        return this.events.addListener(event + ':' + this.channel, callback);
+    }
+}
+exports.default = Subscribe;

package/lib/constants.d.ts

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

package/lib/constants.js

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

package/lib/index.d.ts

@@ -1,6 +1,7 @@
-import { Event } from "easy-event-emitter";
-import Core, { type IConfig, type TPermissions, type TSocketEvents, type TListenerCallback, type TListen } from "./Core";
+import { type Event as EventListener } from "easy-event-emitter";
+import Core from "./Core";
 import Listener from "./Listener";
+import type { IConfig, TPermissions, TSocketEvents, TListenerCallback } from "./types";
 declare class Larasopp extends Core {
     private readonly channels;
     constructor(config: IConfig);
@@ -9,7 +10,8 @@ declare class Larasopp extends Core {
     unsubscribe(channel: string): void;
     trigger<T>(channel: string, event: string, message: T, permission?: TPermissions, waitSubscribe?: boolean): void;
     private pushListener;
-    addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined;
+    countListeners(channel: string): number;
+    addListener(event: TSocketEvents, callback: TListenerCallback): EventListener | undefined;
 }
-export type { TListen };
+export type { Listener, EventListener };
 export default Larasopp;

package/lib/index.js

@@ -1,32 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Core_1 = __importStar(require("./Core"));
+const Core_1 = __importDefault(require("./Core"));
+const constants_1 = require("./constants");
 const Listener_1 = __importDefault(require("./Listener"));
 class Larasopp extends Core_1.default {
     constructor(config) {
@@ -77,14 +55,19 @@ class Larasopp extends Core_1.default {
     pushListener(channel, listener) {
         if (!this.channels[channel]) {
             this.channels[channel] = [];
+            this.send({
+                subscribe: channel
+            });
         }
-        this.send({
-            subscribe: channel
-        });
         this.channels[channel].push(listener);
     }
+    countListeners(channel) {
+        if (!this.channels[channel])
+            return -1;
+        return this.channels[channel].length;
+    }
     addListener(event, callback) {
-        if (!Core_1.SocketEvents.includes(event))
+        if (!constants_1.SocketEvents.includes(event))
             return;
         return this.events.addListener(event, callback);
     }

package/lib/types.d.ts

@@ -0,0 +1,31 @@
+import type Listener from "./Listener";
+import { SocketEvents, ListenerEvents } from "./constants";
+export type TSocketEvents = typeof SocketEvents[number];
+export type TListenerEvents = typeof ListenerEvents[number];
+export type TListenerCallback = (data: {
+    channel: string;
+}) => void;
+export type TPermissions = 'public' | 'protected' | 'private';
+export type TMessage<T> = {
+    subscribe?: string;
+    unsubscribe?: string;
+    channel?: string;
+    event?: string;
+    token?: string;
+    message?: T;
+    type?: TPermissions;
+};
+export type TConfigDataReviver = {
+    [index: string]: (value: any) => any;
+};
+export interface IConfig {
+    host: string;
+    token?: string;
+    reviver?: (this: any, key: string, value: any) => any;
+    dataReviver?: TConfigDataReviver;
+    reconnect?: number;
+    reconnectDelay?: number;
+}
+export type TChannels = {
+    [channel: string]: Listener[];
+};

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larasopp",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "Websocket client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/Core.ts

@@ -1,56 +1,23 @@
 import EventEmitter,{
 	type Events
 } from "easy-event-emitter";
-import type Listener from "./Listener";
-
-export const SocketEvents = ['open', 'close', 'error'] as const;
-export type TSocketEvents = typeof SocketEvents[number];
-
-export const ListenerEvents = ['subscribe', 'unsubscribe'] as const;
-export type TListenerEvents = typeof ListenerEvents[number];
-
-export type TListenerCallback = (data:{channel: string}) => void;
-
-export type TPermissions = 'public' | 'protected' | 'private';
-
-export type TListen = {
-	remove: () => void;
-}
-
-export type TMessage<T> = {
-	subscribe?: string;
-	unsubscribe?: string;
-	channel?: string;
-	event?: string;
-	token?: string;
-	message?: T;
-	type?: TPermissions;
-}
-
-export type TConfigDataReviver = {
-	[index: string]: (value: any) => any;
-};
-
-export interface IConfig {
-	host: string;
-	token?: string;
-	reviver?: (this: any, key: string, value: any) => any;
-	dataReviver?: TConfigDataReviver;
-}
-
-export type TChannels = {
-	[channel: string]: Listener[];
-};
+import { ListenerEvents } from "./constants";
+import type {
+	IConfig,
+	TListenerEvents,
+	TMessage
+} from "./types";
 
 abstract class Core {
 	public readonly events: Events;
 	private ws?: WebSocket;
 	private _socketId?: string;
 	private config: IConfig;
+	private reconnectCount: number;
 
 	constructor(config: IConfig) {
 		this.events = new EventEmitter;
-
+		this.reconnectCount = 0;
 		this.config = config;
 		
 		this.handleOpen = this.handleOpen.bind(this);
@@ -115,12 +82,27 @@ abstract class Core {
 		return true;
 	}
 
+	private tryReconnect() {
+		if (
+			typeof this.config.reconnect === 'undefined' ||
+			this.reconnectCount >= this.config.reconnect ||
+			typeof this.ws === 'undefined' ||
+			this.status ||
+			this.ws?.readyState === this.ws.CONNECTING
+		) return;
+		
+		++this.reconnectCount;
+		this.connect();
+		setTimeout(() => this.tryReconnect(), this.config.reconnectDelay ?? 1000);
+	}
+
 	private handleOpen(e: Event): void {
 		this.events.emit("open", e);
 	}
 
 	private handleClose(e: CloseEvent): void {
 		this.events.emit("close", e);
+		this.tryReconnect();
 	}
 
 	private handleError(e: Event): void {

package/src/Listener.ts

@@ -1,12 +1,12 @@
 import {
-	type Event
+	type Event as EventListener
 } from "easy-event-emitter";
 import type Larasopp from ".";
 
 class Listener {
 	private readonly context: Larasopp;
 	private channel: string;
-	private listeners?: Event[];
+	private listeners?: EventListener[];
 
 	constructor(channel: string, constext: Larasopp) {
 		this.channel = channel;
@@ -22,6 +22,11 @@ class Listener {
 		return listener;
 	}
 
+	public unsubscribe() {
+		this.context.unsubscribe(this.channel);
+		this.remove();
+	}
+
 	public remove() {
 		if (!this.listeners) return;
 		this.listeners.forEach((listener) => listener.remove());

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const SocketEvents = ['open', 'close', 'error'] as const;
+
+export const ListenerEvents = ['subscribe', 'unsubscribe'] as const;

package/src/index.ts

@@ -1,16 +1,16 @@
 import {
-	Event
+	type Event as EventListener
 } from "easy-event-emitter";
-import Core,{
-	type IConfig,
-	type TPermissions,
-	SocketEvents,
-	type TSocketEvents,
-	type TListenerCallback,
-	type TListen,
-	type TChannels
-} from "./Core";
+import Core from "./Core";
+import { SocketEvents } from "./constants";
 import Listener from "./Listener";
+import type {
+	IConfig,
+	TPermissions,
+	TSocketEvents,
+	TListenerCallback,
+	TChannels
+} from "./types";
 
 class Larasopp extends Core {
 	private readonly channels: TChannels;
@@ -63,21 +63,27 @@ class Larasopp extends Core {
 	private pushListener(channel: string, listener: Listener): void {
 		if (!this.channels[channel]) {
 			this.channels[channel] = [];
+			this.send({
+				subscribe: channel
+			});
 		}
-		this.send({
-			subscribe: channel
-		});
 		this.channels[channel].push(listener);
 	}
 
-	public addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined {
+	public countListeners(channel: string) {
+		if (!this.channels[channel]) return -1;
+		return this.channels[channel].length;
+	}
+
+	public addListener(event: TSocketEvents, callback: TListenerCallback): EventListener | undefined {
 		if (!SocketEvents.includes(event)) return;
 		return this.events.addListener(event, callback);
 	}
 }
 
 export type {
-	TListen
+	Listener,
+	EventListener
 };
 
 export default Larasopp;

package/src/types.ts

@@ -0,0 +1,40 @@
+import type Listener from "./Listener";
+import {
+	SocketEvents,
+	ListenerEvents
+} from "./constants";
+
+export type TSocketEvents = typeof SocketEvents[number];
+
+export type TListenerEvents = typeof ListenerEvents[number];
+
+export type TListenerCallback = (data:{channel: string}) => void;
+
+export type TPermissions = 'public' | 'protected' | 'private';
+
+export type TMessage<T> = {
+	subscribe?: string;
+	unsubscribe?: string;
+	channel?: string;
+	event?: string;
+	token?: string;
+	message?: T;
+	type?: TPermissions;
+};
+
+export type TConfigDataReviver = {
+	[index: string]: (value: any) => any;
+};
+
+export interface IConfig {
+	host: string;
+	token?: string;
+	reviver?: (this: any, key: string, value: any) => any;
+	dataReviver?: TConfigDataReviver;
+	reconnect?: number;
+	reconnectDelay?: number;
+};
+
+export type TChannels = {
+	[channel: string]: Listener[];
+};