larasopp 1.2.10 → 1.2.12

package/lib/Listener.d.ts

@@ -1,11 +1,15 @@
-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;
+    here(callback: (data: any) => void): EventListener;
+    joining(callback: (data: any) => void): EventListener;
+    leaving(callback: (data: any) => void): EventListener;
+    unsubscribe(): void;
     remove(): void;
 }
 export default Listener;

package/lib/Listener.js

@@ -31,6 +31,19 @@ class Listener {
         this.listeners.push(listener);
         return listener;
     }
+    here(callback) {
+        return this.listen('__HERE', callback);
+    }
+    joining(callback) {
+        return this.listen('__JOIN', callback);
+    }
+    leaving(callback) {
+        return this.listen('__LEAVE', callback);
+    }
+    unsubscribe() {
+        this.context.unsubscribe(this.channel);
+        this.remove();
+    }
     remove() {
         if (!this.listeners)
             return;

package/lib/index.d.ts

@@ -1,7 +1,7 @@
-import { Event } from "easy-event-emitter";
+import { type Event as EventListener } from "easy-event-emitter";
 import Core from "./Core";
 import Listener from "./Listener";
-import type { IConfig, TPermissions, TSocketEvents, TListenerCallback, TListen } from "./types";
+import type { IConfig, TPermissions, TSocketEvents, TListenerCallback } from "./types";
 declare class Larasopp extends Core {
     private readonly channels;
     constructor(config: IConfig);
@@ -10,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

@@ -55,12 +55,17 @@ 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 (!constants_1.SocketEvents.includes(event))
             return;

package/lib/types.d.ts

@@ -6,9 +6,6 @@ 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;

package/package.json

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

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,23 @@ class Listener {
 		return listener;
 	}
 
+	public here(callback: (data: any) => void) {
+		return this.listen('__HERE', callback);
+	}
+
+	public joining(callback: (data: any) => void) {
+		return this.listen('__JOIN', callback);
+	}
+
+	public leaving(callback: (data: any) => void) {
+		return this.listen('__LEAVE', callback);
+	}
+
+	public unsubscribe() {
+		this.context.unsubscribe(this.channel);
+		this.remove();
+	}
+
 	public remove() {
 		if (!this.listeners) return;
 		this.listeners.forEach((listener) => listener.remove());

package/src/index.ts

@@ -1,5 +1,5 @@
 import {
-	Event
+	type Event as EventListener
 } from "easy-event-emitter";
 import Core from "./Core";
 import { SocketEvents } from "./constants";
@@ -9,7 +9,6 @@ import type {
 	TPermissions,
 	TSocketEvents,
 	TListenerCallback,
-	TListen,
 	TChannels
 } from "./types";
 
@@ -64,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

@@ -12,10 +12,6 @@ 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;