larasopp 1.2.22 → 1.2.23

package/lib/Core.js

@@ -164,12 +164,12 @@ class Core {
                 return;
             }
             this.emitListener(json.channel, json.message);
-            this.events.emit(json.channel + ':' + json.event, json.message);
+            this.events.emit(`${json.channel}:${json.event}`, json.message);
         }
     }
     emitListener(method, channel) {
         if (constants_1.ListenerEvents.includes(method)) {
-            this.events.emit(method + ':' + channel, {
+            this.events.emit(`${method}:${channel}`, {
                 channel
             });
         }

package/lib/Listener.d.ts

@@ -5,6 +5,7 @@ declare class Listener extends EventEmmiter.Stack {
     private channel;
     private listener?;
     private cacheEvents;
+    private hereMap;
     constructor(channel: string, constext: Larasopp);
     listen(event: string, callback: (data: any) => void, withCache?: boolean): this;
     here(callback: (data: any) => void, withCache?: boolean): this;

package/lib/Listener.js

@@ -31,6 +31,12 @@ class Listener extends easy_event_emitter_1.default.Stack {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "hereMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         this.channel = channel;
         this.context = constext;
         this.cacheEvents = {};
@@ -39,7 +45,7 @@ class Listener extends easy_event_emitter_1.default.Stack {
     listen(event, callback, withCache = false) {
         if (withCache && this.hasCache(event))
             callback(this.getCache(event));
-        const listener = this.context.events.addListener(this.channel + ':' + event, (data) => {
+        const listener = this.context.events.addListener(`${this.channel}:${event}`, (data) => {
             callback(data);
             if (withCache)
                 this.pushCache(event, data);
@@ -48,7 +54,20 @@ class Listener extends easy_event_emitter_1.default.Stack {
         return this;
     }
     here(callback, withCache = true) {
-        return this.listen('__HERE', callback, withCache);
+        const listeners = new easy_event_emitter_1.default.Stack();
+        listeners.push(this.joining((join) => {
+            this.hereMap.set(join.id, join);
+            callback([...this.hereMap.values()]);
+        }));
+        listeners.push(this.leaving((leave) => {
+            this.hereMap.delete(leave.id);
+            callback([...this.hereMap.values()]);
+        }));
+        const hereListener = this.listen('__HERE', (here) => {
+            this.hereMap = new Map(here.map((u) => [u.id, u]));
+            callback([...this.hereMap.values()]);
+        }, withCache);
+        return hereListener;
     }
     joining(callback, withCache = false) {
         return this.listen('__JOIN', callback, withCache);

package/lib/index.d.ts

@@ -6,6 +6,8 @@ declare class Larasopp extends Core {
     private readonly channels;
     constructor(config: IConfig);
     private listenResumeSubscribes;
+    user(callback: (user: any) => void): void;
+    userRefresh(callback: (user: any) => void): void;
     subscribe(channel: string): Listener;
     unsubscribe(channel: string): void;
     trigger<T>(channel: string, event: string, message: T, permission?: TPermissions, waitSubscribe?: boolean): void;

package/lib/index.js

@@ -25,6 +25,24 @@ class Larasopp extends Core_1.default {
             }));
         });
     }
+    user(callback) {
+        if (!this.status)
+            return;
+        this.send({ me: true });
+        const listener = this.events.addListener(`__SYSTEM:user`, (e) => {
+            callback(e);
+            listener.remove();
+        });
+    }
+    userRefresh(callback) {
+        if (!this.status)
+            return;
+        this.send({ me: 'refresh' });
+        const listener = this.events.addListener(`__SYSTEM:user-refresh`, (e) => {
+            callback(e);
+            listener.remove();
+        });
+    }
     subscribe(channel) {
         const listener = new Listener_1.default(channel, this);
         this.pushListener(channel, listener);
@@ -49,7 +67,7 @@ class Larasopp extends Core_1.default {
             });
         };
         if (waitSubscribe)
-            this.events.addListener(event + ':' + channel, send);
+            this.events.addListener(`${event}:${channel}`, send);
         send();
     }
     pushListener(channel, listener) {

package/lib/types.d.ts

@@ -14,6 +14,7 @@ export type TMessage<T> = {
     token?: string;
     message?: T;
     type?: TPermissions;
+    me?: true | 'refresh';
 };
 export type TConfigDataReviver = {
     [index: string]: (value: any) => any;

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "larasopp",
-  "version": "1.2.22",
+  "version": "1.2.23",
   "description": "Websocket client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "test": "jest",
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run test && npm run build"
   },
+  "files": [
+    "lib"
+  ],
   "jest": {
     "transform": {
       "^.+\\.[t|j]sx?$": "babel-jest"
     }
   },
-  "files": [
-    "lib"
-  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/SergoMorello/larasopp.client.git"
@@ -41,6 +41,6 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "easy-event-emitter": "^1.2.2"
+    "easy-event-emitter": "^1.1.5"
   }
 }