larasopp 1.0.3 → 1.0.5

package/lib/Core.d.ts

@@ -1,4 +1,11 @@
 import { Events } from "easy-event-emitter";
+export declare const SocketEvents: readonly ["open", "close", "error"];
+export type TSocketEvents = typeof SocketEvents[number];
+export declare const ListenerEvents: readonly ["subscribe", "unsubscribe"];
+export type TListenerEvents = typeof ListenerEvents[number];
+export type TListenerCallback = (data: {
+    channel: string;
+}) => void;
 export type TPermissions = 'public' | 'protected' | 'private';
 export type TMessage<T> = {
     subscribe?: string;
@@ -36,6 +43,7 @@ declare abstract class Core {
     private onClose;
     private onError;
     private onMessage;
+    private emitListener;
     get status(): boolean;
     protected send<T>(message: TMessage<T>): void;
 }

package/lib/Core.js

@@ -3,7 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerEvents = exports.SocketEvents = void 0;
 const easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
+exports.SocketEvents = ['open', 'close', 'error'];
+exports.ListenerEvents = ['subscribe', 'unsubscribe'];
 class Core {
     constructor(config) {
         Object.defineProperty(this, "events", {
@@ -104,16 +107,23 @@ class Core {
     onMessage(e) {
         if (this.isJsonString(e.data)) {
             const json = JSON.parse(e.data);
+            this.emitListener(json.channel, json.message);
             this.events.emit(json.channel + ':' + json.event, json.message);
         }
     }
+    emitListener(method, channel) {
+        if (exports.ListenerEvents.includes(method)) {
+            this.events.emit(method + ':' + channel, {
+                channel
+            });
+        }
+    }
     get status() {
         return this._status;
     }
     send(message) {
-        if (!this.status) {
+        if (!this.status)
             return;
-        }
         this.ws.send(JSON.stringify(message));
     }
 }

package/lib/Subscribe.d.ts

@@ -1,5 +1,5 @@
-import { TMessage } from "./Core";
-import { Events } from "easy-event-emitter";
+import { TMessage, TListenerEvents, TListenerCallback } from "./Core";
+import { Event, Events } from "easy-event-emitter";
 type TReturn = {
     remove: () => void;
 };
@@ -19,5 +19,6 @@ declare class Subscribe {
     private init;
     bind<T>(event: string, callback: (data: T) => void): TReturn;
     remove(): void;
+    addListener(event: TListenerEvents, callback: TListenerCallback): Event | undefined;
 }
 export default Subscribe;

package/lib/Subscribe.js

@@ -66,5 +66,8 @@ class Subscribe {
             unsubscribe: this.channel
         });
     }
+    addListener(event, callback) {
+        return this.events.addListener(event + ':' + this.channel, callback);
+    }
 }
 exports.default = Subscribe;

package/lib/index.d.ts

@@ -1,8 +1,11 @@
-import Core, { IConfig, TPermissions } from "./Core";
+import { Event } from "easy-event-emitter";
+import Core, { IConfig, TPermissions, TSocketEvents, TListenerCallback } from "./Core";
 import Subscribe from "./Subscribe";
 declare class Larasopp extends Core {
     constructor(config: IConfig);
     subscribe(channel: string): Subscribe;
     trigger<T>(channel: string, event: string, message: T, permission?: TPermissions): void;
+    addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined;
 }
+export type { Subscribe };
 export default Larasopp;

package/lib/index.js

@@ -1,9 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Core_1 = __importDefault(require("./Core"));
+const Core_1 = __importStar(require("./Core"));
 const Subscribe_1 = __importDefault(require("./Subscribe"));
 class Larasopp extends Core_1.default {
     constructor(config) {
@@ -27,5 +50,10 @@ class Larasopp extends Core_1.default {
             type: permission
         });
     }
+    addListener(event, callback) {
+        if (!Core_1.SocketEvents.includes(event))
+            return;
+        return this.events.addListener(event, callback);
+    }
 }
 exports.default = Larasopp;

package/package.json

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

package/src/Core.ts

@@ -2,6 +2,14 @@ import EventEmitter,{
 	Events
 } from "easy-event-emitter";
 
+export const SocketEvents = ['open', 'close', 'error'] as const;
+export type TSocketEvents = typeof SocketEvents[number];
+
+export const ListenerEvents = ['subscribe', 'unsubscribe'] as const;
+export type TListenerEvents = typeof ListenerEvents[number];
+
+export type TListenerCallback = (data:{channel: string}) => void;
+
 export type TPermissions = 'public' | 'protected' | 'private';
 
 export type TMessage<T> = {
@@ -122,19 +130,25 @@ abstract class Core {
 	private onMessage(e: any): void {
 		if (this.isJsonString(e.data)) {
 			const json = JSON.parse(e.data);
-			
+			this.emitListener(json.channel, json.message);
 			this.events.emit(json.channel + ':' + json.event, json.message);
 		}
 	}
 
+	private emitListener(method: TListenerEvents, channel: string): void {
+		if (ListenerEvents.includes(method)) {
+			this.events.emit(method + ':' + channel, {
+				channel
+			});
+		}
+	}
+
 	public get status(): boolean {
 		return this._status;
 	}
 
 	protected send<T>(message: TMessage<T>) {
-		if (!this.status) {
-			return;
-		}
+		if (!this.status) return;
 		this.ws!.send(JSON.stringify(message));
 	}
 }

package/src/Subscribe.ts

@@ -1,7 +1,11 @@
 import {
-	TMessage
+	TMessage,
+	ListenerEvents,
+	TListenerEvents,
+	TListenerCallback
 } from "./Core";
 import {
+	Event,
 	Events
 } from "easy-event-emitter";
 
@@ -67,6 +71,10 @@ class Subscribe {
 			unsubscribe: this.channel
 		});
 	}
+
+	public addListener(event: TListenerEvents, callback: TListenerCallback): Event | undefined {
+		return this.events.addListener(event + ':' + this.channel, callback);
+	}
 }
 
 export default Subscribe;

package/src/index.ts

@@ -1,6 +1,12 @@
+import {
+	Event
+} from "easy-event-emitter";
 import Core,{
 	IConfig,
-	TPermissions
+	TPermissions,
+	SocketEvents,
+	TSocketEvents,
+	TListenerCallback
 } from "./Core";
 import Subscribe from "./Subscribe";
 
@@ -30,6 +36,15 @@ class Larasopp extends Core {
 			type: permission
 		});
 	}
+
+	public addListener(event: TSocketEvents, callback: TListenerCallback): Event | undefined {
+		if (!SocketEvents.includes(event)) return;
+		return this.events.addListener(event, callback);
+	}
 }
 
+export type {
+	Subscribe
+};
+
 export default Larasopp;