larasopp 1.1.3 → 1.2.2

package/README.md

@@ -10,6 +10,7 @@ composer require larasopp/larasopp
 ```
 
 ### Connect app to websocket
+
 ```js
 ...
 import Larasopp from "Larasopp";
@@ -21,17 +22,22 @@ const larasopp = new Larasopp({
 
 larasopp.connect();
 
-export default larasopp;
+```
+
+### Update user token
 
+```js
+larasopp.setToken('new token');
 ```
 
-### Subscribe on channel and bind event
+### Subscribe on channel and listen event
+
 ```js
-const listener = larasopp.subscribe('chat').bind('message',(data) => {
+const listener = larasopp.subscribe('chat').listen('message',(data) => {
 	console.log(data.text); // Hello World
 });
 
-// Unsubscribe
+// Unsubscribe event
 listener.remove();
 ```
 
@@ -43,7 +49,14 @@ larasopp.trigger('chat','message',{
 },'public');
 ```
 
+### Unsubscribe channel
+
+```js
+larasopp.unsubscribe('chat');
+```
+
 ### Disconnect
+
 ```js
 larasopp.disconnect();
 ```

package/lib/Core.d.ts

@@ -1,4 +1,5 @@
-import { Events } from "easy-event-emitter";
+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"];
@@ -7,7 +8,7 @@ export type TListenerCallback = (data: {
     channel: string;
 }) => void;
 export type TPermissions = 'public' | 'protected' | 'private';
-export type TBind = {
+export type TListen = {
     remove: () => void;
 };
 export type TMessage<T> = {
@@ -15,6 +16,7 @@ export type TMessage<T> = {
     unsubscribe?: string;
     channel?: string;
     event?: string;
+    token?: string;
     message?: T;
     type?: TPermissions;
 };
@@ -23,10 +25,14 @@ export interface IConfig {
     token?: string;
     tls?: boolean;
 }
+export type TChannels = {
+    [channel: string]: Listener[];
+};
 declare abstract class Core {
-    protected events: Events;
+    readonly events: Events;
     private ws?;
     protected _status: boolean;
+    private _socketId?;
     private config;
     constructor(config: IConfig);
     setConfig(config: IConfig): void;
@@ -41,13 +47,15 @@ declare abstract class Core {
      * @returns {void}
      */
     disconnect(): void;
-    protected isJsonString(str: string): boolean;
-    private onOpen;
-    private onClose;
-    private onError;
-    private onMessage;
+    protected isJson(str: string): boolean;
+    private handleOpen;
+    private handleClose;
+    private handleError;
+    private handleMessage;
     private emitListener;
+    get socketId(): string | undefined;
     get status(): boolean;
+    private _send;
     protected send<T>(message: TMessage<T>): void;
 }
 export default Core;

package/lib/Core.js

@@ -27,6 +27,12 @@ class Core {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_socketId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
@@ -36,20 +42,19 @@ class Core {
         this.events = new easy_event_emitter_1.default;
         this.config = Object.assign({ tls: false }, config);
         this._status = false;
-        this.send = this.send.bind(this);
-        this.setConfig = this.setConfig.bind(this);
-        this.setToken = this.setToken.bind(this);
-        this.connect = this.connect.bind(this);
-        this.onOpen = this.onOpen.bind(this);
-        this.onClose = this.onClose.bind(this);
-        this.onError = this.onError.bind(this);
-        this.onMessage = this.onMessage.bind(this);
+        this.handleOpen = this.handleOpen.bind(this);
+        this.handleClose = this.handleClose.bind(this);
+        this.handleError = this.handleError.bind(this);
+        this.handleMessage = this.handleMessage.bind(this);
     }
     setConfig(config) {
         this.config = Object.assign({ tls: false }, config);
     }
     setToken(token) {
         this.config = Object.assign(Object.assign({}, this.config), { token });
+        this.send({
+            token
+        });
     }
     /**
      * Connect to websocket
@@ -61,17 +66,21 @@ class Core {
             return this;
         }
         try {
-            this.ws = new WebSocket((this.config.tls ? 'wss' : 'ws') + '://' + this.config.host + '/token=' + this.config.token);
+            const host = [(this.config.tls ? 'wss' : 'ws') + '://'];
+            host.push(this.config.host);
+            if (this.config.token)
+                host.push('/token=' + this.config.token);
+            this.ws = new WebSocket(host.join(''));
+            this.ws.onopen = this.handleOpen;
+            this.ws.onclose = this.handleClose;
+            this.ws.onerror = this.handleError;
+            this.ws.onmessage = this.handleMessage;
         }
         catch (e) {
             console.warn(e);
-            this.onError('Socket exception');
-            this.onClose(e);
+            this.handleError(new Event('Socket exception'));
+            this.handleClose(new CloseEvent(String(e)));
         }
-        this.ws.onopen = this.onOpen;
-        this.ws.onclose = this.onClose;
-        this.ws.onerror = this.onError;
-        this.ws.onmessage = this.onMessage;
         return this;
     }
     /**
@@ -84,8 +93,9 @@ class Core {
             (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
             this._status = false;
         }
+        this.ws = undefined;
     }
-    isJsonString(str) {
+    isJson(str) {
         try {
             JSON.parse(str);
         }
@@ -94,20 +104,24 @@ class Core {
         }
         return true;
     }
-    onOpen(e) {
+    handleOpen(e) {
         this._status = true;
         this.events.emit("open", e);
     }
-    onClose(e) {
+    handleClose(e) {
         this._status = false;
         this.events.emit("close", e);
     }
-    onError(e) {
+    handleError(e) {
         this.events.emit("error", e);
     }
-    onMessage(e) {
-        if (this.isJsonString(e.data)) {
+    handleMessage(e) {
+        if (this.isJson(e.data)) {
             const json = JSON.parse(e.data);
+            if (json.socket_id) {
+                this._socketId = json.socket_id;
+                return;
+            }
             this.emitListener(json.channel, json.message);
             this.events.emit(json.channel + ':' + json.event, json.message);
         }
@@ -119,13 +133,29 @@ class Core {
             });
         }
     }
+    get socketId() {
+        return this._socketId;
+    }
     get status() {
+        if (!this._status)
+            this.connect();
         return this._status;
     }
-    send(message) {
-        if (!this.status)
+    _send(message) {
+        if (!this.ws)
             return;
         this.ws.send(JSON.stringify(message));
     }
+    send(message) {
+        if (this.status) {
+            this._send(message);
+        }
+        else {
+            const event = this.events.addListener('open', () => {
+                this._send(message);
+                event.remove();
+            });
+        }
+    }
 }
 exports.default = Core;

package/lib/Listener.d.ts

@@ -0,0 +1,11 @@
+import { type Event } 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;
+    remove(): void;
+}
+export default Listener;

package/lib/Listener.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Listener {
+    constructor(channel, constext) {
+        Object.defineProperty(this, "context", {
+            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, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channel = channel;
+        this.context = constext;
+    }
+    listen(event, callback) {
+        if (!this.listeners) {
+            this.listeners = [];
+        }
+        const listener = this.context.events.addListener(this.channel + ':' + event, callback);
+        this.listeners.push(listener);
+        return listener;
+    }
+    remove() {
+        if (!this.listeners)
+            return;
+        this.listeners.forEach((listener) => listener.remove());
+    }
+}
+exports.default = Listener;

package/lib/Subscribe.d.ts

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

package/lib/Subscribe.js

@@ -79,7 +79,7 @@ class Subscribe {
             });
         }
     }
-    bind(event, callback) {
+    listen(event, callback) {
         const Event = this.events.addListener(this.channel + ':' + event, callback);
         this.currentEvents.push(Event);
         return {

package/lib/index.d.ts

@@ -1,16 +1,15 @@
 import { Event } from "easy-event-emitter";
-import Core, { IConfig, TPermissions, TSocketEvents, TListenerCallback, TBind } from "./Core";
-import Subscribe from "./Subscribe";
+import Core, { type IConfig, type TPermissions, type TSocketEvents, type TListenerCallback, type TListen } from "./Core";
+import Listener from "./Listener";
 declare class Larasopp extends Core {
-    private _channels;
+    private readonly channels;
     constructor(config: IConfig);
-    subscribe(channel: string): Subscribe;
+    private listenResumeSubscribes;
+    subscribe(channel: string): Listener;
+    unsubscribe(channel: string): void;
     trigger<T>(channel: string, event: string, message: T, permission?: TPermissions, waitSubscribe?: boolean): void;
-    private pushChannel;
-    private removeChannel;
-    private get channels();
-    hasChannel(channel: string): boolean;
+    private pushListener;
     addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined;
 }
-export type { Subscribe, TBind };
+export type { TListen };
 export default Larasopp;

package/lib/index.js

@@ -27,32 +27,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Core_1 = __importStar(require("./Core"));
-const Subscribe_1 = __importDefault(require("./Subscribe"));
+const Listener_1 = __importDefault(require("./Listener"));
 class Larasopp extends Core_1.default {
     constructor(config) {
         super(config);
-        Object.defineProperty(this, "_channels", {
+        Object.defineProperty(this, "channels", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this._channels = [];
-        this.subscribe = this.subscribe.bind(this);
-        this.trigger = this.trigger.bind(this);
-        this.hasChannel = this.hasChannel.bind(this);
-        this.pushChannel = this.pushChannel.bind(this);
-        this.removeChannel = this.removeChannel.bind(this);
+        this.channels = {};
+        this.listenResumeSubscribes();
+    }
+    listenResumeSubscribes() {
+        this.addListener('open', () => {
+            Object.keys(this.channels).forEach((channel) => this.send({
+                subscribe: channel
+            }));
+        });
     }
     subscribe(channel) {
-        return new Subscribe_1.default({
-            events: this.events,
-            hasChannel: this.hasChannel,
-            pushChannel: this.pushChannel,
-            removeChannel: this.removeChannel,
-            status: this.status,
-            send: this.send,
-            channel
+        const listener = new Listener_1.default(channel, this);
+        this.pushListener(channel, listener);
+        return listener;
+    }
+    unsubscribe(channel) {
+        if (!this.channels[channel])
+            return;
+        this.channels[channel].forEach((listener) => listener.remove());
+        delete this.channels[channel];
+        this.send({
+            unsubscribe: channel
         });
     }
     trigger(channel, event, message, permission = 'public', waitSubscribe = false) {
@@ -68,21 +74,14 @@ class Larasopp extends Core_1.default {
             this.events.addListener(event + ':' + channel, send);
         send();
     }
-    pushChannel(channel) {
-        if (this._channels.indexOf(channel) >= 0)
-            return;
-        this._channels.push(channel);
-    }
-    removeChannel(channel) {
-        const index = this._channels.indexOf(channel);
-        if (index >= 0)
-            this._channels.splice(index, 1);
-    }
-    get channels() {
-        return this._channels;
-    }
-    hasChannel(channel) {
-        return this.channels.indexOf(channel) >= 0;
+    pushListener(channel, listener) {
+        if (!this.channels[channel]) {
+            this.channels[channel] = [];
+        }
+        this.send({
+            subscribe: channel
+        });
+        this.channels[channel].push(listener);
     }
     addListener(event, callback) {
         if (!Core_1.SocketEvents.includes(event))

package/package.json

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

package/src/Core.ts

@@ -1,6 +1,7 @@
 import EventEmitter,{
-	Events
+	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];
@@ -12,7 +13,7 @@ export type TListenerCallback = (data:{channel: string}) => void;
 
 export type TPermissions = 'public' | 'protected' | 'private';
 
-export type TBind = {
+export type TListen = {
 	remove: () => void;
 }
 
@@ -21,6 +22,7 @@ export type TMessage<T> = {
 	unsubscribe?: string;
 	channel?: string;
 	event?: string;
+	token?: string;
 	message?: T;
 	type?: TPermissions;
 }
@@ -31,10 +33,15 @@ export interface IConfig {
 	tls?: boolean;
 }
 
+export type TChannels = {
+	[channel: string]: Listener[];
+};
+
 abstract class Core {
-	protected events: Events;
+	public readonly events: Events;
 	private ws?: WebSocket;
 	protected _status: boolean;
+	private _socketId?: string;
 	private config: IConfig;
 
 	constructor(config: IConfig) {
@@ -46,14 +53,10 @@ abstract class Core {
 		};
 		this._status = false;
 
-		this.send = this.send.bind(this);
-		this.setConfig = this.setConfig.bind(this);
-		this.setToken = this.setToken.bind(this);
-		this.connect = this.connect.bind(this);
-		this.onOpen = this.onOpen.bind(this);
-		this.onClose = this.onClose.bind(this);
-		this.onError = this.onError.bind(this);
-		this.onMessage = this.onMessage.bind(this);
+		this.handleOpen = this.handleOpen.bind(this);
+		this.handleClose = this.handleClose.bind(this);
+		this.handleError = this.handleError.bind(this);
+		this.handleMessage = this.handleMessage.bind(this);
 	}
 
 	public setConfig(config: IConfig): void {
@@ -68,6 +71,9 @@ abstract class Core {
 			...this.config,
 			token
 		};
+		this.send({
+			token
+		});
 	}
 
 	/**
@@ -75,24 +81,21 @@ abstract class Core {
 	 * @returns {this}
 	 */
 	public connect(): this {
-
-		if (!navigator.onLine) {
-			setTimeout(this.connect.bind(this), 5000);
-			return this;
-		}
-
 		try {
-			this.ws = new WebSocket((this.config.tls ? 'wss' : 'ws') + '://' + this.config.host + '/token=' + this.config.token);
+			const host = [(this.config.tls ? 'wss' : 'ws') + '://'];
+			host.push(this.config.host);
+			if (this.config.token) host.push('/token=' + this.config.token);
+
+			this.ws = new WebSocket(host.join(''));
+			this.ws.onopen = this.handleOpen;
+			this.ws.onclose = this.handleClose;
+			this.ws.onerror = this.handleError;
+			this.ws.onmessage = this.handleMessage;
 		}catch(e) {
 			console.warn(e);
-			this.onError('Socket exception');
-			this.onClose(e);
+			this.handleError(new Event('Socket exception'));
+			this.handleClose(new CloseEvent(String(e)));
 		}
-
-		this.ws!.onopen = this.onOpen;
-		this.ws!.onclose = this.onClose;
-		this.ws!.onerror = this.onError;
-		this.ws!.onmessage = this.onMessage;
 		
 		return this;
 	}
@@ -106,9 +109,10 @@ abstract class Core {
 			this.ws?.close();
 			this._status = false;
 		}
+		this.ws = undefined;
 	}
 
-	protected isJsonString(str: string) {
+	protected isJson(str: string) {
 		try {
 			JSON.parse(str);
 		} catch (e) {
@@ -117,23 +121,27 @@ abstract class Core {
 		return true;
 	}
 
-	private onOpen(e: any): void {
+	private handleOpen(e: Event): void {
 		this._status = true;
 		this.events.emit("open", e);
 	}
 
-	private onClose(e: any): void {
+	private handleClose(e: CloseEvent): void {
 		this._status = false;
 		this.events.emit("close", e);
 	}
 
-	private onError(e: any): void {
+	private handleError(e: Event): void {
 		this.events.emit("error", e);
 	}
 
-	private onMessage(e: any): void {
-		if (this.isJsonString(e.data)) {
+	private handleMessage(e: MessageEvent): void {
+		if (this.isJson(e.data)) {
 			const json = JSON.parse(e.data);
+			if (json.socket_id) {
+				this._socketId = json.socket_id;
+				return;
+			}
 			this.emitListener(json.channel, json.message);
 			this.events.emit(json.channel + ':' + json.event, json.message);
 		}
@@ -147,13 +155,29 @@ abstract class Core {
 		}
 	}
 
+	public get socketId() {
+		return this._socketId;
+	}
+
 	public get status(): boolean {
+		if (!this._status) this.connect();
 		return this._status;
 	}
 
+	private _send<T>(message: TMessage<T>) {
+		if (!this.ws) return;
+		this.ws.send(JSON.stringify(message));
+	}
+
 	protected send<T>(message: TMessage<T>) {
-		if (!this.status) return;
-		this.ws!.send(JSON.stringify(message));
+		if (this.status) {
+			this._send(message);
+		}else{
+			const event = this.events.addListener('open',() => {
+				this._send(message);
+				event.remove();
+			});
+		}
 	}
 }
 

package/src/Listener.ts

@@ -0,0 +1,31 @@
+import {
+	type Event
+} from "easy-event-emitter";
+import type Larasopp from ".";
+
+class Listener {
+	private readonly context: Larasopp;
+	private channel: string;
+	private listeners?: Event[];
+
+	constructor(channel: string, constext: Larasopp) {
+		this.channel = channel;
+		this.context = constext;
+	}
+
+	public listen(event: string, callback: (data: any) => void) {
+		if (!this.listeners) {
+			this.listeners = [];
+		}
+		const listener = this.context.events.addListener(this.channel + ':' + event, callback);
+		this.listeners.push(listener);
+		return listener;
+	}
+
+	public remove() {
+		if (!this.listeners) return;
+		this.listeners.forEach((listener) => listener.remove());
+	}
+}
+
+export default Listener;

package/src/index.ts

@@ -2,39 +2,47 @@ import {
 	Event
 } from "easy-event-emitter";
 import Core,{
-	IConfig,
-	TPermissions,
+	type IConfig,
+	type TPermissions,
 	SocketEvents,
-	TSocketEvents,
-	TListenerCallback,
-	TBind
+	type TSocketEvents,
+	type TListenerCallback,
+	type TListen,
+	type TChannels
 } from "./Core";
-import Subscribe from "./Subscribe";
+import Listener from "./Listener";
 
 class Larasopp extends Core {
-	private _channels: string[];
+	private readonly channels: TChannels;
 
 	constructor(config: IConfig) {
 		super(config);
 		
-		this._channels = [];
+		this.channels = {};
 
-		this.subscribe = this.subscribe.bind(this);
-		this.trigger = this.trigger.bind(this);
-		this.hasChannel = this.hasChannel.bind(this);
-		this.pushChannel = this.pushChannel.bind(this);
-		this.removeChannel = this.removeChannel.bind(this);
+		this.listenResumeSubscribes();
 	}
 
-	public subscribe(channel: string): Subscribe {
-		return new Subscribe({
-			events: this.events,
-			hasChannel: this.hasChannel,
-			pushChannel: this.pushChannel,
-			removeChannel: this.removeChannel,
-			status: this.status,
-			send: this.send,
-			channel
+	private listenResumeSubscribes() {
+		this.addListener('open', () => {
+			Object.keys(this.channels).forEach((channel) => this.send({
+				subscribe: channel
+			}));
+		});
+	}
+
+	public subscribe(channel: string) {
+		const listener = new Listener(channel, this);
+		this.pushListener(channel, listener);
+		return listener;
+	}
+
+	public unsubscribe(channel: string) {
+		if (!this.channels[channel]) return;
+		this.channels[channel].forEach((listener) => listener.remove());
+		delete this.channels[channel];
+		this.send({
+			unsubscribe: channel
 		});
 	}
 
@@ -52,22 +60,14 @@ class Larasopp extends Core {
 		send();
 	}
 
-	private pushChannel(channel: string): void {
-		if (this._channels.indexOf(channel) >= 0) return;
-		this._channels.push(channel);
-	}
-
-	private removeChannel(channel: string): void {
-		const index = this._channels.indexOf(channel);
-		if (index >= 0) this._channels.splice(index, 1);
-	}
-
-	private get channels(): string[] {
-		return this._channels;
-	}
-
-	public hasChannel(channel: string): boolean {
-		return this.channels.indexOf(channel) >= 0;
+	private pushListener(channel: string, listener: Listener): void {
+		if (!this.channels[channel]) {
+			this.channels[channel] = [];
+		}
+		this.send({
+			subscribe: channel
+		});
+		this.channels[channel].push(listener);
 	}
 
 	public addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined {
@@ -77,8 +77,7 @@ class Larasopp extends Core {
 }
 
 export type {
-	Subscribe,
-	TBind
+	TListen
 };
 
 export default Larasopp;

package/src/Subscribe.ts

@@ -1,96 +0,0 @@
-import {
-	TMessage,
-	ListenerEvents,
-	TListenerEvents,
-	TListenerCallback,
-	TBind
-} from "./Core";
-import {
-	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;
-}
-
-class Subscribe {
-	private events: Events;
-	private currentEvents: Event[];
-	private hasChannel: (channel: string) => boolean;
-	private pushChannel: (channel: string) => void;
-	private removeChannel: (channel: string) => void;
-	private status: boolean;
-	private _channel: string;
-	private send: <T>(message: TMessage<T>) => void;
-
-	constructor({events, hasChannel, pushChannel, removeChannel, status, channel, send}: ISubscribe) {
-		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();
-	}
-
-	public get channel(): string {
-		return this._channel;
-	}
-
-	private init(): void {
-		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();
-			});
-		}
-	}
-
-	public bind<T>(event: string, callback: (data: T) => void): TBind {
-		const Event = this.events.addListener(this.channel + ':' + event, callback);
-		this.currentEvents.push(Event);
-		return {
-			remove: () => {
-				Event.remove();
-			}
-		}
-	}
-
-	private clearEvents(): void {
-		this.currentEvents.forEach((event) => event.remove());
-	}
-
-	public remove(): void {
-		this.clearEvents();
-		this.removeChannel(this.channel);
-		if (this.hasChannel(this.channel)) return;
-		this.send({
-			unsubscribe: this.channel
-		});
-	}
-
-	public addListener(event: TListenerEvents, callback: TListenerCallback): Event | undefined {
-		return this.events.addListener(event + ':' + this.channel, callback);
-	}
-}
-
-export default Subscribe;