larasopp 1.0.4 → 1.0.6

package/lib/Core.d.ts

@@ -1,4 +1,6 @@
 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: {

package/lib/Core.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListenerEvents = void 0;
+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) {
@@ -121,9 +122,8 @@ class Core {
         return this._status;
     }
     send(message) {
-        if (!this.status) {
+        if (!this.status)
             return;
-        }
         this.ws.send(JSON.stringify(message));
     }
 }

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

@@ -1,8 +1,16 @@
-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 {
+    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 };
 export default Larasopp;

package/lib/index.js

@@ -1,31 +1,93 @@
 "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) {
         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))
+            return;
+        return this.events.addListener(event, callback);
     }
 }
 exports.default = Larasopp;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larasopp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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

@@ -2,6 +2,9 @@ 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];
 
@@ -47,7 +50,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 {
@@ -133,7 +135,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
 			});
@@ -145,9 +147,7 @@ abstract class Core {
 	}
 
 	protected send<T>(message: TMessage<T>) {
-		if (!this.status) {
-			return;
-		}
+		if (!this.status) return;
 		this.ws!.send(JSON.stringify(message));
 	}
 }

package/src/Subscribe.ts

@@ -15,6 +15,9 @@ 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;
@@ -22,12 +25,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 +49,8 @@ class Subscribe {
 	}
 
 	private init(): void {
+		this.pushChannel(this.channel);
+
 		if (this.status) {
 			this.send({
 				subscribe: this.channel
@@ -58,15 +69,15 @@ class Subscribe {
 		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

@@ -1,35 +1,82 @@
+import {
+	Event
+} from "easy-event-emitter";
 import Core,{
 	IConfig,
-	TPermissions
+	TPermissions,
+	SocketEvents,
+	TSocketEvents,
+	TListenerCallback
 } 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 {
+		if (!SocketEvents.includes(event)) return;
+		return this.events.addListener(event, callback);
 	}
 }
 
+export type {
+	Subscribe
+};
+
 export default Larasopp;