larasopp 1.0.2 → 1.0.4

package/lib/Core.d.ts

@@ -1,11 +1,16 @@
 import { Events } from "easy-event-emitter";
+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';
-type TMessage = {
+export type TMessage<T> = {
     subscribe?: string;
     unsubscribe?: string;
     channel?: string;
     event?: string;
-    message?: any;
+    message?: T;
     type?: TPermissions;
 };
 export interface IConfig {
@@ -16,7 +21,7 @@ export interface IConfig {
 declare abstract class Core {
     protected events: Events;
     private ws?;
-    protected status: boolean;
+    protected _status: boolean;
     private config;
     constructor(config: IConfig);
     setConfig(config: IConfig): void;
@@ -36,6 +41,8 @@ declare abstract class Core {
     private onClose;
     private onError;
     private onMessage;
-    protected send(message: TMessage): void;
+    private emitListener;
+    get status(): boolean;
+    protected send<T>(message: TMessage<T>): void;
 }
 export default Core;

package/lib/Core.js

@@ -3,7 +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;
 const easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
+exports.ListenerEvents = ['subscribe', 'unsubscribe'];
 class Core {
     constructor(config) {
         Object.defineProperty(this, "events", {
@@ -18,7 +20,7 @@ class Core {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "status", {
+        Object.defineProperty(this, "_status", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -32,7 +34,8 @@ class Core {
         });
         this.events = new easy_event_emitter_1.default;
         this.config = Object.assign({ tls: false }, config);
-        this.status = false;
+        this._status = false;
+        this.send = this.send.bind(this);
         this.setConfig = this.setConfig.bind(this);
         this.setToken = this.setToken.bind(this);
         this.connect = this.connect.bind(this);
@@ -64,10 +67,6 @@ class Core {
             this.onError('Socket exception');
             this.onClose(e);
         }
-        // this.handleTimeout = setTimeout(() => {
-        // 	this.ws?.close(1000, 'timeout');
-        // },this.timeout);
-        // this.startReconnect();
         this.ws.onopen = this.onOpen;
         this.ws.onclose = this.onClose;
         this.ws.onerror = this.onError;
@@ -94,24 +93,11 @@ class Core {
         return true;
     }
     onOpen(e) {
-        this.status = true;
+        this._status = true;
         this.events.emit("open", e);
     }
     onClose(e) {
-        // if (e.wasClean) {
-        // 	console.log('Соединение закрыто чисто');
-        // } else {
-        // 	if (Larasopp.stepReconnect >= 5) {
-        // 		console.log('connect error');
-        // 	}else{
-        // 		setTimeout(() => {
-        // 			console.log('try reconnect...');
-        // 			Larasopp.connect(params);
-        // 			++Larasopp.stepReconnect;
-        // 		}, 3000);
-        // 	}
-        // }
-        this.status = false;
+        this._status = false;
         this.events.emit("close", e);
     }
     onError(e) {
@@ -120,9 +106,20 @@ 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) {
             return;

package/lib/Subscribe.d.ts

@@ -0,0 +1,24 @@
+import { TMessage, TListenerEvents, TListenerCallback } from "./Core";
+import { Event, Events } from "easy-event-emitter";
+type TReturn = {
+    remove: () => void;
+};
+interface ISubscribe {
+    events: Events;
+    send: <T>(message: TMessage<T>) => void;
+    channel: string;
+    status: boolean;
+}
+declare class Subscribe {
+    private events;
+    private status;
+    private _channel;
+    private send;
+    constructor({ events, status, channel, send }: ISubscribe);
+    get channel(): string;
+    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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Subscribe {
+    constructor({ events, status, channel, send }) {
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "send", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.events = events;
+        this.status = status;
+        this._channel = channel;
+        this.send = send;
+        this.init();
+    }
+    get channel() {
+        return this._channel;
+    }
+    init() {
+        if (this.status) {
+            this.send({
+                subscribe: this.channel
+            });
+        }
+        else {
+            const event = this.events.addListener('open', () => {
+                this.send({
+                    subscribe: this.channel
+                });
+                event.remove();
+            });
+        }
+    }
+    bind(event, callback) {
+        const Event = this.events.addListener(this.channel + ':' + event, callback);
+        return {
+            remove: () => {
+                this.send({
+                    unsubscribe: this.channel
+                });
+                Event.remove();
+            }
+        };
+    }
+    remove() {
+        this.send({
+            unsubscribe: this.channel
+        });
+    }
+    addListener(event, callback) {
+        return this.events.addListener(event + ':' + this.channel, callback);
+    }
+}
+exports.default = Subscribe;

package/lib/index.d.ts

@@ -1,11 +1,8 @@
 import Core, { IConfig, TPermissions } from "./Core";
-export default class Larasopp extends Core {
+import Subscribe from "./Subscribe";
+declare class Larasopp extends Core {
     constructor(config: IConfig);
-    subscribe(channel: string): {
-        bind: (event: string, callback: (data: any) => void) => {
-            remove: () => void;
-        };
-        remove: () => void;
-    };
-    trigger(channel: string, event: string, message: any, permission?: TPermissions): void;
+    subscribe(channel: string): Subscribe;
+    trigger<T>(channel: string, event: string, message: T, permission?: TPermissions): void;
 }
+export default Larasopp;

package/lib/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Core_1 = __importDefault(require("./Core"));
+const Subscribe_1 = __importDefault(require("./Subscribe"));
 class Larasopp extends Core_1.default {
     constructor(config) {
         super(config);
@@ -11,37 +12,12 @@ class Larasopp extends Core_1.default {
         this.trigger = this.trigger.bind(this);
     }
     subscribe(channel) {
-        if (this.status) {
-            this.send({
-                subscribe: channel
-            });
-        }
-        else {
-            const event = this.events.addListener('open', () => {
-                this.send({
-                    subscribe: channel
-                });
-                event.remove();
-            });
-        }
-        return {
-            bind: (event, callback) => {
-                const retEvent = this.events.addListener(channel + ':' + event, callback);
-                return {
-                    remove: () => {
-                        this.send({
-                            unsubscribe: channel
-                        });
-                        retEvent.remove();
-                    }
-                };
-            },
-            remove: () => {
-                this.send({
-                    unsubscribe: channel
-                });
-            }
-        };
+        return new Subscribe_1.default({
+            events: this.events,
+            status: this.status,
+            send: this.send,
+            channel
+        });
     }
     trigger(channel, event, message, permission = 'public') {
         this.send({

package/package.json

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

package/src/Core.ts

@@ -2,14 +2,19 @@ import EventEmitter,{
 	Events
 } from "easy-event-emitter";
 
+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';
 
-type TMessage = {
+export type TMessage<T> = {
 	subscribe?: string;
 	unsubscribe?: string;
 	channel?: string;
 	event?: string;
-	message?: any;
+	message?: T;
 	type?: TPermissions;
 }
 
@@ -22,7 +27,7 @@ export interface IConfig {
 abstract class Core {
 	protected events: Events;
 	private ws?: WebSocket;
-	protected status: boolean;
+	protected _status: boolean;
 	private config: IConfig;
 
 	constructor(config: IConfig) {
@@ -32,8 +37,9 @@ abstract class Core {
 			tls: false,
 			...config,
 		};
-		this.status = false;
+		this._status = false;
 
+		this.send = this.send.bind(this);
 		this.setConfig = this.setConfig.bind(this);
 		this.setToken = this.setToken.bind(this);
 		this.connect = this.connect.bind(this);
@@ -77,12 +83,6 @@ abstract class Core {
 			this.onClose(e);
 		}
 
-		// this.handleTimeout = setTimeout(() => {
-		// 	this.ws?.close(1000, 'timeout');
-		// },this.timeout);
-
-		// this.startReconnect();
-
 		this.ws!.onopen = this.onOpen;
 		this.ws!.onclose = this.onClose;
 		this.ws!.onerror = this.onError;
@@ -111,25 +111,12 @@ abstract class Core {
 	}
 
 	private onOpen(e: any): void {
-		this.status = true;
+		this._status = true;
 		this.events.emit("open", e);
 	}
 
 	private onClose(e: any): void {
-		// if (e.wasClean) {
-		// 	console.log('Соединение закрыто чисто');
-		// } else {
-		// 	if (Larasopp.stepReconnect >= 5) {
-		// 		console.log('connect error');
-		// 	}else{
-		// 		setTimeout(() => {
-		// 			console.log('try reconnect...');
-		// 			Larasopp.connect(params);
-		// 			++Larasopp.stepReconnect;
-		// 		}, 3000);
-		// 	}
-		// }
-		this.status = false;
+		this._status = false;
 		this.events.emit("close", e);
 	}
 
@@ -140,12 +127,24 @@ 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);
 		}
 	}
 
-	protected send(message: TMessage) {
+	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;
 		}

package/src/Subscribe.ts

@@ -0,0 +1,80 @@
+import {
+	TMessage,
+	ListenerEvents,
+	TListenerEvents,
+	TListenerCallback
+} from "./Core";
+import {
+	Event,
+	Events
+} from "easy-event-emitter";
+
+type TReturn = {
+	remove: () => void;
+}
+
+interface ISubscribe {
+	events: Events;
+	send: <T>(message: TMessage<T>) => void;
+	channel: string;
+	status: boolean;
+}
+
+class Subscribe {
+	private events: Events;
+	private status: boolean;
+	private _channel: string;
+	private send: <T>(message: TMessage<T>) => void;
+
+	constructor({events, status, channel, send}: ISubscribe) {
+		this.events = events;
+		this.status = status;
+		this._channel = channel;
+		this.send = send;
+
+		this.init();
+	}
+
+	public get channel(): string {
+		return this._channel;
+	}
+
+	private init(): void {
+		if (this.status) {
+			this.send({
+				subscribe: this.channel
+			});
+		}else{
+			const event = this.events.addListener('open',() => {
+				this.send({
+					subscribe: this.channel
+				});
+				event.remove();
+			});
+		}
+	}
+
+	public bind<T>(event: string, callback: (data: T) => void): TReturn {
+		const Event = this.events.addListener(this.channel + ':' + event, callback);
+		return {
+			remove: () => {
+				this.send({
+					unsubscribe: this.channel
+				});
+				Event.remove();
+			}
+		}
+	}
+
+	public remove(): void {
+		this.send({
+			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

@@ -2,56 +2,34 @@ import Core,{
 	IConfig,
 	TPermissions
 } from "./Core";
+import Subscribe from "./Subscribe";
 
-export default class Larasopp extends Core {
+class Larasopp extends Core {
 
 	constructor(config: IConfig) {
 		super(config);
-
+		
 		this.subscribe = this.subscribe.bind(this);
 		this.trigger = this.trigger.bind(this);
 	}
 
-	public subscribe(channel: string) {
-		if (this.status) {
-			this.send({
-				subscribe: channel
-			});
-		}else{
-			const event = this.events.addListener('open',() => {
-				this.send({
-					subscribe: channel
-				});
-				event.remove();
-			});
-		}
-		
-		return {
-			bind: (event: string, callback: (data: any) => void) => {
-				const retEvent = this.events.addListener(channel + ':' + event, callback);
-				return {
-					remove: () => {
-						this.send({
-							unsubscribe: channel
-						});
-						retEvent.remove();
-					}
-				}
-			},
-			remove: () => {
-				this.send({
-					unsubscribe: channel
-				});
-			}
-		}
+	public subscribe(channel: string): Subscribe {
+		return new Subscribe({
+			events: this.events,
+			status: this.status,
+			send: this.send,
+			channel
+		});
 	}
 
-	public trigger(channel: string, event: string, message: any, permission: TPermissions = 'public'): void {
-		this.send({
+	public trigger<T>(channel: string, event: string, message: T, permission: TPermissions = 'public'): void {
+		this.send<T>({
 			channel: channel,
 			event: event,
 			message: message,
 			type: permission
 		});
 	}
-}
+}
+
+export default Larasopp;