larasopp 1.0.5 → 1.0.7

package/lib/Subscribe.d.ts

@@ -5,16 +5,22 @@ type TReturn = {
 };
 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 hasChannel;
+    private pushChannel;
+    private removeChannel;
     private status;
     private _channel;
     private send;
-    constructor({ events, status, channel, send }: ISubscribe);
+    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }: ISubscribe);
     get channel(): string;
     private init;
     bind<T>(event: string, callback: (data: T) => void): TReturn;

package/lib/Subscribe.js

@@ -1,13 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class Subscribe {
-    constructor({ events, status, channel, send }) {
+    constructor({ events, hasChannel, pushChannel, removeChannel, status, channel, send }) {
         Object.defineProperty(this, "events", {
             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,
@@ -27,6 +45,9 @@ class Subscribe {
             value: void 0
         });
         this.events = events;
+        this.hasChannel = hasChannel;
+        this.pushChannel = pushChannel;
+        this.removeChannel = removeChannel;
         this.status = status;
         this._channel = channel;
         this.send = send;
@@ -36,6 +57,7 @@ class Subscribe {
         return this._channel;
     }
     init() {
+        this.pushChannel(this.channel);
         if (this.status) {
             this.send({
                 subscribe: this.channel
@@ -54,14 +76,15 @@ class Subscribe {
         const Event = this.events.addListener(this.channel + ':' + event, callback);
         return {
             remove: () => {
-                this.send({
-                    unsubscribe: this.channel
-                });
+                this.remove();
                 Event.remove();
             }
         };
     }
     remove() {
+        this.removeChannel(this.channel);
+        if (this.hasChannel(this.channel))
+            return;
         this.send({
             unsubscribe: this.channel
         });

package/lib/index.d.ts

@@ -2,9 +2,14 @@ import { Event } from "easy-event-emitter";
 import Core, { IConfig, TPermissions, TSocketEvents, TListenerCallback } from "./Core";
 import Subscribe from "./Subscribe";
 declare class Larasopp extends Core {
+    private _channels;
     constructor(config: IConfig);
     subscribe(channel: string): Subscribe;
-    trigger<T>(channel: string, event: string, message: T, permission?: TPermissions): 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;
     addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined;
 }
 export type { Subscribe };

package/lib/index.js

@@ -31,24 +31,58 @@ const Subscribe_1 = __importDefault(require("./Subscribe"));
 class Larasopp extends Core_1.default {
     constructor(config) {
         super(config);
+        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);
     }
     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
         });
     }
-    trigger(channel, event, message, permission = 'public') {
-        this.send({
-            channel: channel,
-            event: event,
-            message: message,
-            type: permission
-        });
+    trigger(channel, event, message, permission = 'public', waitSubscribe = false) {
+        const send = () => {
+            this.send({
+                channel: channel,
+                event: event,
+                message: message,
+                type: permission
+            });
+        };
+        if (waitSubscribe)
+            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;
     }
     addListener(event, callback) {
         if (!Core_1.SocketEvents.includes(event))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larasopp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Websocket client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,6 +37,6 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "easy-event-emitter": "^1.0.6"
+    "easy-event-emitter": "^1.0.7"
   }
 }

package/src/Core.ts

@@ -12,6 +12,10 @@ export type TListenerCallback = (data:{channel: string}) => void;
 
 export type TPermissions = 'public' | 'protected' | 'private';
 
+export type TBind = {
+	remove: () => void;
+}
+
 export type TMessage<T> = {
 	subscribe?: string;
 	unsubscribe?: string;
@@ -50,7 +54,6 @@ abstract class Core {
 		this.onClose = this.onClose.bind(this);
 		this.onError = this.onError.bind(this);
 		this.onMessage = this.onMessage.bind(this);
-		
 	}
 
 	public setConfig(config: IConfig): void {
@@ -136,7 +139,7 @@ abstract class Core {
 	}
 
 	private emitListener(method: TListenerEvents, channel: string): void {
-		if (ListenerEvents.includes(method)) {
+		if (ListenerEvents.includes(method)) {	
 			this.events.emit(method + ':' + channel, {
 				channel
 			});

package/src/Subscribe.ts

@@ -2,19 +2,20 @@ import {
 	TMessage,
 	ListenerEvents,
 	TListenerEvents,
-	TListenerCallback
+	TListenerCallback,
+	TBind
 } from "./Core";
 import {
 	Event,
 	Events
 } from "easy-event-emitter";
 
-type TReturn = {
-	remove: () => void;
-}
 
 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;
@@ -22,12 +23,18 @@ interface ISubscribe {
 
 class Subscribe {
 	private events: Events;
+	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, status, channel, send}: ISubscribe) {
+	constructor({events, hasChannel, pushChannel, removeChannel, status, channel, send}: ISubscribe) {
 		this.events = events;
+		this.hasChannel = hasChannel;
+		this.pushChannel = pushChannel;
+		this.removeChannel = removeChannel;
 		this.status = status;
 		this._channel = channel;
 		this.send = send;
@@ -40,6 +47,8 @@ class Subscribe {
 	}
 
 	private init(): void {
+		this.pushChannel(this.channel);
+
 		if (this.status) {
 			this.send({
 				subscribe: this.channel
@@ -54,19 +63,19 @@ class Subscribe {
 		}
 	}
 
-	public bind<T>(event: string, callback: (data: T) => void): TReturn {
+	public bind<T>(event: string, callback: (data: T) => void): TBind {
 		const Event = this.events.addListener(this.channel + ':' + event, callback);
 		return {
 			remove: () => {
-				this.send({
-					unsubscribe: this.channel
-				});
+				this.remove();
 				Event.remove();
 			}
 		}
 	}
 
 	public remove(): void {
+		this.removeChannel(this.channel);
+		if (this.hasChannel(this.channel)) return;
 		this.send({
 			unsubscribe: this.channel
 		});

package/src/index.ts

@@ -6,35 +6,68 @@ import Core,{
 	TPermissions,
 	SocketEvents,
 	TSocketEvents,
-	TListenerCallback
+	TListenerCallback,
+	TBind
 } from "./Core";
 import Subscribe from "./Subscribe";
 
 class Larasopp extends Core {
+	private _channels: string[];
 
 	constructor(config: IConfig) {
 		super(config);
 		
+		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);
 	}
 
 	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
 		});
 	}
 
-	public trigger<T>(channel: string, event: string, message: T, permission: TPermissions = 'public'): void {
-		this.send<T>({
-			channel: channel,
-			event: event,
-			message: message,
-			type: permission
-		});
+	public trigger<T>(channel: string, event: string, message: T, permission: TPermissions = 'public', waitSubscribe: boolean = false): void {
+		const send = () => {
+			this.send<T>({
+				channel: channel,
+				event: event,
+				message: message,
+				type: permission
+			});
+		};
+		
+		if (waitSubscribe) this.events.addListener(event + ':' + channel, send);
+		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;
 	}
 
 	public addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined {
@@ -44,7 +77,8 @@ class Larasopp extends Core {
 }
 
 export type {
-	Subscribe
+	Subscribe,
+	TBind
 };
 
 export default Larasopp;