insite-subscriptions-client 1.0.295 → 2.0.0

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "insite-subscriptions-client",
-  "version": "1.0.295",
+  "version": "2.0.0",
   "description": "inSite subscriptions client side",
   "type": "module",
-  "main": "./lib/index.js",
-  "module": "./lib/index.js",
-  "packageManager": "bun@1.1.9",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "packageManager": "bun@1.1.26",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "bun .conveyer.js",
+    "postbuild": "tsc -p ."
   },
   "repository": {
     "type": "git",
@@ -22,14 +24,13 @@
   "author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
   "license": "MIT",
   "dependencies": {
-    "@nesvet/n": "^1",
-    "eventemitter3": "^5"
+    "@nesvet/n": "^1.1.7",
+    "eventemitter3": "^5.0.1",
+    "insite-ws": "^2"
   },
   "devDependencies": {
-    "@nesvet/eslint-config": "^1"
-  },
-  "peerDependencies": {
-    "insite-subscriptions-server": "^1",
-    "insite-ws": "^1"
+    "@nesvet/conveyer": "^2.2.4",
+    "@nesvet/eslint-config": "^2.0.25",
+    "typescript": "^5.5.4"
   }
 }

package/{lib/Subscription.js → src/Subscription.ts}

@@ -1,26 +1,18 @@
-//#if _SSR
-// import { publications } from "insite-subscriptions-server";
+import type { InSiteWebSocket } from "insite-ws/client";
 
 
-// export const initialsMap = new Map();
-
-// export const subscriptionContext = {};
-
-// export async function Subscription(type, publicationName, args = [], handler) {
-// 	const value = await publications.get(publicationName)?.fetch(subscriptionContext, ...args);
-
-// 	subscriptionContext.initials.push(JSON.stringify(value));
-
-// 	handler(value);
+declare global {
+	var __initials: undefined | unknown[];// eslint-disable-line no-var
+}
 
-// }
 
+let i: number;
+let subscriptions: Map<number, Subscription>;
+let ws: InSiteWebSocket;
 
-//#else
-let i, subscriptions, ws;
 
 export class Subscription {
-	constructor(type, publicationName, args = [], handler, immediately = true) {
+	constructor(type: "array" | "map" | "object", publicationName: string, args: unknown[] = [], handler: (updates: unknown) => void, immediately = true) {
 		
 		if (!ws)
 			throw new Error("Subscription is not binded to WS. Do Subscription.bindTo(ws) first");
@@ -47,6 +39,14 @@ export class Subscription {
 		
 	}
 	
+	i;
+	type;
+	publicationName;
+	args;
+	handler;
+	immediately;
+	isActive;
+	
 	start = () => {
 		
 		ws.sendMessage("s-s"/* subscription subscribe */, this.type, this.publicationName, this.i, this.args, this.immediately);
@@ -66,20 +66,18 @@ export class Subscription {
 	}
 	
 	
-	static bindTo(_ws) {
+	static bindTo(_ws: InSiteWebSocket) {
 		ws = _ws;
 		
 		i = 0;
 		
-		subscriptions =
-			Subscription.subscriptions =
-				new Map();
+		subscriptions = new Map();
 		
-		ws.on("message:s-c"/* subscription changed */, (_i, data) => {
-			const subscription = subscriptions.get(_i);
+		ws.on("message:s-c"/* subscription changed */, (si: number, updates: unknown) => {
+			const subscription = subscriptions.get(si);
 			if (subscription) {
 				subscription.isActive = true;
-				subscription.handler(data);
+				subscription.handler(updates);
 			}
 			
 		});
@@ -101,6 +99,3 @@ export class Subscription {
 	}
 	
 }
-
-
-//#endif

package/{lib/SubscriptionArray.js → src/SubscriptionArray.ts}

@@ -14,38 +14,65 @@ import {
 } from "./symbols";
 
 
-const ascSort = (a, b) => a > b ? 1 : a < b ? -1 : 0;
-const descSort = (a, b) => a > b ? -1 : a < b ? 1 : 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
 
-export class SubscriptionArray extends Array {
-	constructor(updates, onUpdate) {
+type Item = unknown;
+
+type Updated<I extends Item = Item> = {
+	deleted: I[];
+	added: I[];
+} & I[];
+
+export type Updates<I extends Item = Item> =
+	(
+		[ "a"/* add */, newItem: I ] |
+		[ "d"/* delete */, itemToDelete: I ] |
+		[ "i"/* initial */, items: I[], sort?: -1 | 1 ] |
+		null
+	)[] |
+	null;
+
+type UpdateHandler<I extends Item = Item> = (array: SubscriptionArray<I>, updated: Updated<I>, updates: Updates<I>) => void;
+
+const ascSort = (a: any, b: any) => a > b ? 1 : a < b ? -1 : 0;
+const descSort = (a: any, b: any) => a > b ? -1 : a < b ? 1 : 0;
+
+
+export class SubscriptionArray<I extends Item = Item> extends Array<I> {
+	constructor(updates?: Updates<I>, onUpdate?: UpdateHandler<I>) {
 		super();
 		
-		this.handleUpdate = onUpdate;
+		if (onUpdate)
+			this.handleUpdate = onUpdate;
 		
 		if (Array.isArray(updates))
 			this.update(updates);
 		
 	}
 	
-	sortDirection = 0;
+	sorted: Item[] = [];
 	
-	sortCompareFunction = null;
+	handleUpdate;
+	
+	sortDirection: -1 | 0 | 1 = 0;
+	
+	sortCompareFunction: null | typeof ascSort | typeof descSort = null;
 	
 	[getHandleUpdateSymbol]() {
 		return this.handleUpdate;
 	}
 	
-	[setHandleUpdateSymbol](handleUpdate) {
+	[setHandleUpdateSymbol](handleUpdate: UpdateHandler<I>) {
 		return (this.handleUpdate = handleUpdate);
 	}
 	
-	update(updates) {
+	update(updates: Updates<I>) {
 		
-		const updated = [];
-		updated.deleted = [];
-		updated.added = [];
+		const updated: Updated<I> = Object.assign([], {
+			deleted: [],
+			added: []
+		});
 		
 		if (updates) {
 			let shouldSort = false;
@@ -76,7 +103,7 @@ export class SubscriptionArray extends Array {
 					}
 					
 					case "a"/* add */: {
-						const newItem = update[1];
+						const [ , newItem ] = update;
 						
 						if (!this.includes(newItem)) {
 							this.push(newItem);
@@ -90,7 +117,7 @@ export class SubscriptionArray extends Array {
 					}
 					
 					case "d"/* delete */: {
-						const itemToDelete = update[1];
+						const [ , itemToDelete ] = update;
 						
 						if (removeOne(this, itemToDelete))
 							updated.deleted.push(itemToDelete);
@@ -102,13 +129,13 @@ export class SubscriptionArray extends Array {
 						this.clear();
 				}
 			
-			if (shouldSort)
+			if (shouldSort && this.sortCompareFunction)
 				this.sort(this.sortCompareFunction);
 			
 		} else
 			this.clear();
 		
-		this.handleUpdate?.(this, updated, updates?.[0] && updates);
+		this.handleUpdate?.(this, updated, updates?.[0] ? updates : null);
 		
 		return this;
 	}
@@ -159,12 +186,13 @@ export class SubscriptionArray extends Array {
 	static getAsUpdatesSymbol = getAsUpdatesSymbol;
 	static getAsInitialUpdatedSymbol = getAsInitialUpdatedSymbol;
 	static clearSymbol = clearSymbol;
+	static WithSubscription: typeof SubscriptionArrayWithSubscription;
 	
 }
 
 
-SubscriptionArray.WithSubscription = class SubscriptionArrayWithSubscription extends SubscriptionArray {
-	constructor(publicationName, params, onUpdate, immediately = true) {
+export class SubscriptionArrayWithSubscription<I extends Item = Item> extends SubscriptionArray<I> {
+	constructor(publicationName: string, params: unknown[], onUpdate: UpdateHandler<I>, immediately = true) {
 		super(null, onUpdate);
 		
 		this.publicationName = publicationName;
@@ -175,12 +203,14 @@ SubscriptionArray.WithSubscription = class SubscriptionArrayWithSubscription ext
 		
 	}
 	
-	subscription = null;
+	publicationName;
+	params;
+	subscription: null | Subscription = null;
 	
 	subscribe() {
 		
 		if (!this.subscription)
-			this.subscription = new Subscription("array", this.publicationName, this.params, updates => this.update(updates));
+			this.subscription = new Subscription("array", this.publicationName, this.params, updates => this.update(updates as Updates<I>));
 		
 	}
 	
@@ -201,7 +231,7 @@ SubscriptionArray.WithSubscription = class SubscriptionArrayWithSubscription ext
 		return this.unsubscribe;
 	}
 	
-	renew(publicationName, params) {
+	renew(publicationName?: string, params?: unknown[]) {
 		
 		if (this.subscription) {
 			this.unsubscribe();
@@ -238,4 +268,8 @@ SubscriptionArray.WithSubscription = class SubscriptionArrayWithSubscription ext
 	static renewSymbol = renewSymbol;
 	static getSubscriptionSymbol = getSubscriptionSymbol;
 	
-};
+}
+
+SubscriptionArray.WithSubscription = SubscriptionArrayWithSubscription;
+
+export { Updated as SubscriptionArrayUpdated };

package/{lib/SubscriptionGroup/SubscriptionGroup.js → src/SubscriptionGroup/SubscriptionGroup.ts}

@@ -1,80 +1,107 @@
-import { debounce } from "@nesvet/n";
 import EventEmitter from "eventemitter3";
+import { debounce, StatefulPromise } from "@nesvet/n";
 import { privates } from "./common";
 import { SubscriptionGroupItem } from "./SubscriptionGroupItem";
+import {
+	Definition,
+	ParseValues,
+	SubscriptionHandle,
+	SubscriptionOnBeforeInit,
+	SubscriptionType,
+	TupleDefinition,
+	UnparsedDefinition
+} from "./types";
 
 
-function parseDefinition(definition) {
-	if (Array.isArray(definition)) {
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+
+function isTupleDefinition<T extends SubscriptionType>(definition: UnparsedDefinition<T>): definition is TupleDefinition {
+	return Array.isArray(definition);
+}
+
+type Target = any;
+
+type Options = {
+	target?: Target;
+	debounce?: number;
+	immediately?: boolean;
+};
+
+
+function parseDefinition<T extends SubscriptionType>(definition: UnparsedDefinition<T>) {
+	if (isTupleDefinition(definition)) {
 		const args = definition.slice();
 		
-		const parsed = {};
+		const parsed: Partial<Definition<T>> = {};
 		
-		parsed.name = args.shift();
+		parsed.name = args.shift() as Definition<T>["name"];
 		if (typeof args[0] == "object" && !Array.isArray(args[0])) {
-			parsed.value = args.shift();
-			parsed.type = parsed.value.toString().match(/Subscription(Object|Array|Map)/)[1];
-			if (parsed.type)
-				parsed.type = parsed.type.toLowerCase();
-			else
+			parsed.value = args.shift() as Definition<T>["value"];
+			parsed.type = parsed.value!.toString().match(/Subscription(Object|Array|Map)/)?.[1].toLowerCase() as Definition<T>["type"];
+			if (!parsed.type)
 				throw new Error("Unknown value type");
 		} else {
 			if (typeof args[0] == "string")
-				parsed.type = args.shift();
+				parsed.type = args.shift() as Definition<T>["type"];
 			if (typeof args[0] == "string")
-				parsed.publicationName = args.shift();
+				parsed.publicationName = args.shift() as Definition<T>["publicationName"];
 			if (Array.isArray(args[0]))
-				parsed.params = args.shift();
+				parsed.params = args.shift() as Definition<T>["params"];
 		}
+		
 		if (typeof args[0] == "function")
-			parsed.handle = args.shift();
+			parsed.handle = args.shift() as SubscriptionHandle<T>;
 		if (typeof args[0] == "function")
-			parsed.onBeforeInit = args.shift();
+			parsed.onBeforeInit = args.shift() as SubscriptionOnBeforeInit<T>;
 		if (typeof args[0] == "number")
-			parsed.debounceLimit = args.shift();
+			parsed.debounce = args.shift() as Definition<T>["debounce"];
 		if (typeof args[0] == "boolean")
-			parsed.preventBind = args.shift();
+			parsed.preventBind = args.shift() as Definition<T>["preventBind"];
 		
-		return parsed;
+		return parsed as Definition<T>;
 	}
 	
+	definition.type ??= "object" as T;
+	
 	return definition;
 }
 
-export class SubscriptionGroup extends EventEmitter {
-	constructor(definitions, options = {}) {
-		super();
-		
-		const {
+export class SubscriptionGroup<DS extends UnparsedDefinition[] = any[]> extends EventEmitter {
+	constructor(
+		definitions: DS,
+		{
 			target,
 			debounce: debounceLimit = SubscriptionGroup.debounceLimit,
 			immediately
-		} = options;
+		}: Options = {}
+	) {
+		super();
 		
-		this.#applyOptions({ target, debounceLimit });
+		this.applyOptions({ target, debounceLimit });
 		
-		this.#initPromise = new Promise(resolve => (this.#initResolve = resolve));
+		this.#initPromise = new StatefulPromise();
 		
 		this.attach(definitions, false, immediately);
 		
 	}
 	
-	items = [];
-	values = [];
+	target?: Target;
+	emitUpdate!: () => void;
+	
+	items = [] as unknown as Record<string, SubscriptionGroupItem> & SubscriptionGroupItem[];
+	values = [] as DS extends any ? (any[] & Record<string, any>) : ParseValues<DS>;
 	
 	isLoaded = false;
 	isInited = false;
 	
-	#loadPromise;
-	#initPromise;
-	#unloadPromise;
-	#loadResolve;
-	#initResolve;
-	#unloadResolve;
+	#loadPromise!: StatefulPromise<SubscriptionGroup>;
+	#initPromise: StatefulPromise<SubscriptionGroup>;
+	#unloadPromise!: StatefulPromise<SubscriptionGroup>;
 	
-	#debounceLimit = null;
+	#debounceLimit?: null | number = null;
 	
-	#applyOptions({ target, debounceLimit }) {
+	applyOptions({ target, debounceLimit }: { target?: Target; debounceLimit?: number }) {
 		
 		if (this.target !== target) {
 			if (this.target)
@@ -101,15 +128,15 @@ export class SubscriptionGroup extends EventEmitter {
 		
 	}
 	
-	attach(definitions, shouldReload = this.isLoaded, immediately = true) {
+	attach(definitions: DS, shouldReload = this.isLoaded, immediately = true) {
 		if (shouldReload)
 			this.isLoaded = false;
 		
-		if (!this.#loadPromise || this.#loadPromise.isResolved)
-			this.#loadPromise = new Promise(resolve => (this.#loadResolve = resolve));
+		if (!this.#loadPromise || this.#loadPromise.isFulfilled)
+			this.#loadPromise = new StatefulPromise();
 		
-		if (!this.#unloadPromise || this.#unloadPromise.isResolved)
-			this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+		if (!this.#unloadPromise || this.#unloadPromise.isFulfilled)
+			this.#unloadPromise = new StatefulPromise();
 		
 		return Promise.all(definitions.map(definition =>
 			new SubscriptionGroupItem(parseDefinition(definition), this)
@@ -122,7 +149,7 @@ export class SubscriptionGroup extends EventEmitter {
 		}));
 	}
 	
-	detach(names, shouldUpdate = true) {
+	detach(names: string[], shouldUpdate = true) {
 		
 		for (const name of names)
 			this.items[name]?.detach();
@@ -134,11 +161,11 @@ export class SubscriptionGroup extends EventEmitter {
 		
 	}
 	
-	redefine(definitions) {
+	redefine(definitions: DS) {
 		
 		const itemsToDetach = new Map(this.items.map(item => [ item.name, item ]));
 		const definitionsToRedefine = [];
-		const definitionsToAttach = [];
+		const definitionsToAttach = [] as unknown as DS;
 		
 		for (let definition of definitions) {
 			definition = parseDefinition(definition);
@@ -184,7 +211,7 @@ export class SubscriptionGroup extends EventEmitter {
 			this.isLoaded = true;
 			
 			for (const item of this.items)
-				privates.itemLoad(item);
+				privates.itemLoad!(item);
 			
 			this.emit("load", this.values);
 			
@@ -196,11 +223,10 @@ export class SubscriptionGroup extends EventEmitter {
 					this.emitUpdate();
 			
 			
-			this.#loadResolve(this);
-			this.#loadPromise.isResolved = true;
+			this.#loadPromise.resolve(this);
 			
-			if (this.#unloadPromise.isResolved)
-				this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+			if (this.#unloadPromise.isFulfilled)
+				this.#unloadPromise = new StatefulPromise();
 		}
 		
 	}
@@ -219,11 +245,11 @@ export class SubscriptionGroup extends EventEmitter {
 			
 			
 			for (const item of this.items)
-				privates.itemInit(item);
+				privates.itemInit!(item);
 			
 			this.emit("init", this.values);
 			
-			this.#initResolve(this);
+			this.#initPromise.resolve(this);
 		}
 		
 	}
@@ -239,7 +265,7 @@ export class SubscriptionGroup extends EventEmitter {
 			this.isLoaded = false;
 			
 			for (const item of this.items)
-				privates.itemUnload(item);
+				privates.itemUnload!(item);
 			
 			this.emit("unload", this.values);
 			
@@ -249,11 +275,10 @@ export class SubscriptionGroup extends EventEmitter {
 			else
 				this.emitUpdate();
 			
-			this.#unloadResolve(this);
-			this.#unloadPromise.isResolved = true;
+			this.#unloadPromise.resolve(this);
 			
-			if (this.#loadPromise.isResolved)
-				this.#loadPromise = new Promise(resolve => (this.#loadResolve = resolve));
+			if (this.#loadPromise.isFulfilled)
+				this.#loadPromise = new StatefulPromise();
 		}
 		
 	}
@@ -283,10 +308,12 @@ export class SubscriptionGroup extends EventEmitter {
 	
 	static {
 		
-		privates.groupLoad = group => group.#load();
-		privates.groupInit = group => group.#init();
-		privates.groupUnload = group => group.#unload();
+		privates.groupLoad = (group: SubscriptionGroup) => group.#load();
+		privates.groupInit = (group: SubscriptionGroup) => group.#init();
+		privates.groupUnload = (group: SubscriptionGroup) => group.#unload();
 		
 	}
 	
 }
+
+export { Options as SubscriptionGroupOptions, Target as SubscriptionGroupTarget };