larasopp 1.2.12 → 1.2.14

package/lib/Listener.d.ts

@@ -1,15 +1,21 @@
 import { type Event as EventListener } from "easy-event-emitter";
 import type Larasopp from ".";
-declare class Listener {
+declare class Listener implements EventListener {
     private readonly context;
     private channel;
     private listeners?;
+    private listener?;
+    private cacheEvents;
     constructor(channel: string, constext: Larasopp);
-    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;
+    listen(event: string, callback: (data: any) => void, withCache?: boolean): this;
+    here(callback: (data: any) => void, withCache?: boolean): this;
+    joining(callback: (data: any) => void, withCache?: boolean): this;
+    leaving(callback: (data: any) => void, withCache?: boolean): this;
     unsubscribe(): void;
     remove(): void;
+    private hasCache;
+    private getCache;
+    private pushCache;
+    emit(data: any): void;
 }
 export default Listener;

package/lib/Listener.js

@@ -20,25 +20,45 @@ class Listener {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "listener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cacheEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channel = channel;
         this.context = constext;
+        this.cacheEvents = {};
+        this.here(() => { }, true);
     }
-    listen(event, callback) {
+    listen(event, callback, withCache = false) {
         if (!this.listeners) {
             this.listeners = [];
         }
-        const listener = this.context.events.addListener(this.channel + ':' + event, callback);
+        if (withCache && this.hasCache(event))
+            callback(this.getCache(event));
+        const listener = this.context.events.addListener(this.channel + ':' + event, (data) => {
+            const result = callback(data);
+            if (withCache)
+                this.pushCache(event, result);
+        });
         this.listeners.push(listener);
-        return listener;
+        return this;
     }
-    here(callback) {
-        return this.listen('__HERE', callback);
+    here(callback, withCache = true) {
+        return this.listen('__HERE', callback, withCache);
     }
-    joining(callback) {
-        return this.listen('__JOIN', callback);
+    joining(callback, withCache = false) {
+        return this.listen('__JOIN', callback, withCache);
     }
-    leaving(callback) {
-        return this.listen('__LEAVE', callback);
+    leaving(callback, withCache = false) {
+        return this.listen('__LEAVE', callback, withCache);
     }
     unsubscribe() {
         this.context.unsubscribe(this.channel);
@@ -49,5 +69,15 @@ class Listener {
             return;
         this.listeners.forEach((listener) => listener.remove());
     }
+    hasCache(event) {
+        return event in this.cacheEvents;
+    }
+    getCache(event) {
+        return this.cacheEvents[event];
+    }
+    pushCache(event, data) {
+        this.cacheEvents[event] = data;
+    }
+    emit(data) { }
 }
 exports.default = Listener;

package/package.json

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

package/src/Listener.ts

@@ -3,35 +3,49 @@ import {
 } from "easy-event-emitter";
 import type Larasopp from ".";
 
-class Listener {
+type TListenerCacheEvents = {
+	[event: string]: unknown;
+};
+
+class Listener implements EventListener {
 	private readonly context: Larasopp;
 	private channel: string;
 	private listeners?: EventListener[];
+	private listener?: EventListener;
+	private cacheEvents: TListenerCacheEvents;
 
 	constructor(channel: string, constext: Larasopp) {
 		this.channel = channel;
 		this.context = constext;
+		this.cacheEvents = {};
+
+		this.here(()=>{}, true);
 	}
 
-	public listen(event: string, callback: (data: any) => void) {
+	public listen(event: string, callback: (data: any) => void, withCache = false) {
 		if (!this.listeners) {
 			this.listeners = [];
 		}
-		const listener = this.context.events.addListener(this.channel + ':' + event, callback);
+		
+		if (withCache && this.hasCache(event)) callback(this.getCache(event));
+		const listener = this.context.events.addListener(this.channel + ':' + event, (data) => {
+			const result = callback(data);
+			if (withCache) this.pushCache(event, result);
+		});
 		this.listeners.push(listener);
-		return listener;
+		return this;
 	}
 
-	public here(callback: (data: any) => void) {
-		return this.listen('__HERE', callback);
+	public here(callback: (data: any) => void, withCache = true) {
+		return this.listen('__HERE', callback, withCache);
 	}
 
-	public joining(callback: (data: any) => void) {
-		return this.listen('__JOIN', callback);
+	public joining(callback: (data: any) => void, withCache = false) {
+		return this.listen('__JOIN', callback, withCache);
 	}
 
-	public leaving(callback: (data: any) => void) {
-		return this.listen('__LEAVE', callback);
+	public leaving(callback: (data: any) => void, withCache = false) {
+		return this.listen('__LEAVE', callback, withCache);
 	}
 
 	public unsubscribe() {
@@ -43,6 +57,20 @@ class Listener {
 		if (!this.listeners) return;
 		this.listeners.forEach((listener) => listener.remove());
 	}
+
+	private hasCache(event: string) {
+		return event in this.cacheEvents;
+	}
+
+	private getCache(event: string) {
+		return this.cacheEvents[event];
+	}
+
+	private pushCache(event: string, data: unknown) {
+		this.cacheEvents[event] = data;
+	}
+
+	public emit(data: any): void {}
 }
 
 export default Listener;