insite-subscriptions-client 1.0.295 → 2.0.0

package/src/SubscriptionGroup/SubscriptionGroupItem.ts

@@ -0,0 +1,391 @@
+import EventEmitter from "eventemitter3";
+import { debounce, removeOne, StatefulPromise } from "@nesvet/n";
+import { type SubscriptionArrayUpdated, SubscriptionArrayWithSubscription } from "../SubscriptionArray";
+import { type SubscriptionMapUpdated, SubscriptionMapWithSubscription } from "../SubscriptionMap";
+import { type Updated as SubscriptionObjectUpdated, SubscriptionObjectWithSubscription } from "../SubscriptionObject";
+import {
+	renewSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol
+} from "../symbols";
+import { privates } from "./common";
+import type { SubscriptionGroup } from "./SubscriptionGroup";
+import type {
+	Definition,
+	SubscriptionHandle,
+	SubscriptionOnBeforeInit,
+	SubscriptionType,
+	SubscriptionUpdated,
+	SubscriptionUpdates,
+	SubscriptionValue
+} from "./types";
+
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+
+type HandleSubscription<T> = (_: any, updated: SubscriptionUpdated<T>, updates: SubscriptionUpdates<T>) => void;
+
+function isUpdatedMapOrArray(updated: SubscriptionUpdated<SubscriptionType>): updated is SubscriptionArrayUpdated | SubscriptionMapUpdated {
+	return Array.isArray(updated);
+}
+
+
+export class SubscriptionGroupItem<T extends SubscriptionType = SubscriptionType, D extends Definition<T> = Definition<T>> extends EventEmitter {
+	constructor(definition: D, group: SubscriptionGroup) {
+		super();
+		
+		this.name = definition.name;
+		
+		this.define(definition, group);
+		
+	}
+	
+	name;
+	group?: SubscriptionGroup;
+	value?: SubscriptionValue<T>;
+	type!: "object" | T;
+	publicationName!: Definition<T>["publicationName"];
+	params!: Definition<T>["params"];
+	handle!: Definition<T>["handle"];
+	onBeforeInit!: Definition<T>["onBeforeInit"];
+	preventBind!: Definition<T>["preventBind"];
+	
+	emitUpdate!: (updated?: SubscriptionUpdated<T>) => void;
+	
+	isLoaded = false;
+	isInited = false;
+	
+	#loadPromise!: StatefulPromise<SubscriptionGroupItem<T, D>>;
+	#initPromise!: StatefulPromise<SubscriptionGroupItem<T, D>>;
+	#unloadPromise!: StatefulPromise<SubscriptionGroupItem<T, D>>;
+	
+	define(definition: Definition<T>, group: SubscriptionGroup | undefined = this.group) {
+		if (!group)
+			throw new Error("group is undefined");
+		
+		const {
+			value,
+			type = "object",
+			publicationName,
+			params,
+			handle,
+			onBeforeInit,
+			debounce: debounceLimit = SubscriptionGroupItem.debounceLimit,
+			preventBind
+		} = definition;
+		
+		if (this.group) {
+			if (
+				(!value || this.value === value) &&
+				this.type === type &&
+				this.publicationName === publicationName &&
+				JSON.stringify(this.params) === JSON.stringify(params) &&
+				this.handle === handle &&
+				this.onBeforeInit === onBeforeInit
+			)
+				return this.#applyOptions({ debounceLimit, preventBind });
+			
+			this.detach();
+			delete this.value;
+			delete this.publicationName;
+			delete this.params;
+		}
+		
+		this.type = type;
+		this.handle = handle;
+		this.onBeforeInit = onBeforeInit;
+		if (value)
+			this.value = value;
+		else {
+			this.publicationName = publicationName ?? this.name;
+			this.params = params ?? [];
+		}
+		
+		this.#applyOptions({ debounceLimit, preventBind });
+		
+		this.#attachTo(group);
+		
+		return null;
+	}
+	
+	#applyOptions({ debounceLimit, preventBind }: { debounceLimit?: number; preventBind?: boolean }) {
+		
+		const emitUpdate: typeof this.emitUpdate = updated => {
+			this.emit("update", this.value, updated);
+			this.group?.emit(`update.${this.name}`, this.value, updated);
+			this.group?.emitUpdate();
+			
+		};
+		
+		if (typeof debounceLimit == "number") {
+			let debouncedUpdated: SubscriptionUpdated<T> | undefined;
+			let group: SubscriptionGroup;
+			
+			const emitUpdateDebounced = debounce(() => {
+				
+				const isDetached = !this.group;
+				
+				if (isDetached)
+					this.group = group;
+				
+				emitUpdate(debouncedUpdated!);
+				
+				if (isDetached)
+					delete this.group;
+				
+				debouncedUpdated = undefined;
+				
+			}, debounceLimit);
+			
+			this.emitUpdate = updated => {
+				if (updated !== undefined)
+					if (isUpdatedMapOrArray(updated))
+						if (isUpdatedMapOrArray(debouncedUpdated!))
+							for (const item of updated)
+								debouncedUpdated.push(item as any);
+						else
+							debouncedUpdated = Object.assign([ ...updated ], {
+								added: [ ...updated.added ],
+								deleted: [ ...updated.deleted ]
+							}) as SubscriptionUpdated<T>;
+					else if (typeof updated == "object")
+						if (debouncedUpdated)
+							Object.assign(debouncedUpdated, updated);
+						else
+							debouncedUpdated = { ...updated };
+					else
+						debouncedUpdated = updated;
+				
+				group = this.group!;
+				
+				return emitUpdateDebounced();
+			};
+		} else
+			this.emitUpdate = emitUpdate;
+		
+		if (this.preventBind === undefined)
+			delete this.preventBind;
+		else
+			this.preventBind = preventBind;
+		
+	}
+	
+	#attachTo(group: SubscriptionGroup) {
+		if (!this.group) {
+			this.group = group;
+			
+			this.group.items.push(this);
+			this.group.items[this.name] = this;
+			
+			if (!this.#loadPromise || this.#loadPromise.isFulfilled)
+				this.#loadPromise = new StatefulPromise();
+			
+			if (!this.#initPromise || this.#initPromise.isFulfilled)
+				this.#initPromise = new StatefulPromise();
+			
+			if (!this.#unloadPromise || this.#unloadPromise.isFulfilled)
+				this.#unloadPromise = new StatefulPromise();
+			
+			switch (this.type) {
+				case "array": {
+					const handleSubscription = this.#handleSubscription as HandleSubscription<"array">;
+					if (this.value)
+						(this.value as SubscriptionArrayWithSubscription)[setHandleUpdateSymbol](handleSubscription);
+					else
+						this.value = new SubscriptionArrayWithSubscription(this.publicationName!, this.params!, handleSubscription, false) as SubscriptionValue<T>;
+					break;
+				} case "map": {
+					const handleSubscription = this.#handleSubscription as HandleSubscription<"map">;
+					if (this.value)
+						(this.value as SubscriptionMapWithSubscription)[setHandleUpdateSymbol](handleSubscription);
+					else
+						this.value = new SubscriptionMapWithSubscription(this.publicationName!, this.params!, handleSubscription, false) as SubscriptionValue<T>;
+					break;
+				} default: {
+					const handleSubscription = this.#handleSubscription as HandleSubscription<"object">;
+					if (this.value)
+						(this.value as SubscriptionObjectWithSubscription)[setHandleUpdateSymbol](handleSubscription);
+					else
+						this.value = new SubscriptionObjectWithSubscription(this.publicationName!, this.params!, handleSubscription, false) as SubscriptionValue<T>;
+				}
+			}
+			
+			this.group.values.push(this.value);
+			this.group.values[this.name] = this.value;
+			
+			if (this.onBeforeInit)
+				switch (this.type) {
+					case "array":
+						(this.onBeforeInit as SubscriptionOnBeforeInit<"array">).call(this.group, this.value as SubscriptionArrayWithSubscription);
+						break;
+					case "map":
+						(this.onBeforeInit as SubscriptionOnBeforeInit<"map">).call(this.group, this.value as SubscriptionMapWithSubscription);
+						break;
+					default:
+						(this.onBeforeInit as SubscriptionOnBeforeInit<"object">).call(this.group, this.value as SubscriptionObjectWithSubscription);
+				}
+		}
+		
+	}
+	
+	detach() {
+		
+		if (this.group) {
+			this.value?.[unsubscribeSymbol]();
+			
+			this.isLoaded = false;
+			this.#unload();
+			
+			delete this.group.values[this.name];
+			removeOne(this.group.values, this.value);
+			delete this.group.items[this.name];
+			removeOne(this.group.items, this);
+			
+			delete this.group;
+		}
+		
+	}
+	
+	#loadUpdated: null | SubscriptionUpdated<T> = null;
+	
+	#handleSubscription: HandleSubscription<T> = (_, updated, updates) => {
+		if (updates)
+			if (this.group!.isLoaded) {
+				if (this.handle)
+					switch (this.type) {
+						case "array":
+							(this.handle as SubscriptionHandle<"array">).call(this.group!, updated as SubscriptionArrayUpdated, this.group!);
+							break;
+						case "map":
+							(this.handle as SubscriptionHandle<"map">).call(this.group!, updated as SubscriptionMapUpdated, this.group!);
+							break;
+						default:
+							(this.handle as SubscriptionHandle<"object">).call(this.group!, updated as SubscriptionObjectUpdated, this.group!);
+					}
+				this.emitUpdate(updated);
+			} else {
+				this.#loadUpdated = updated;
+				this.isLoaded = true;
+				privates.groupLoad!(this.group!);
+			}
+		else if (this.isLoaded) {
+			this.isLoaded = false;
+			privates.groupUnload!(this.group!);
+		}
+		
+		if (!this.isInited) {
+			this.isInited = true;
+			privates.groupInit!(this.group!);
+		}
+		
+	};
+	
+	#load() {
+		
+		if (this.#loadUpdated) {
+			if (this.handle)
+				switch (this.type) {
+					case "array":
+						(this.handle as SubscriptionHandle<"array">).call(this.group!, this.#loadUpdated as SubscriptionArrayUpdated, this.group!);
+						break;
+					case "map":
+						(this.handle as SubscriptionHandle<"map">).call(this.group!, this.#loadUpdated as SubscriptionMapUpdated, this.group!);
+						break;
+					default:
+						(this.handle as SubscriptionHandle<"object">).call(this.group!, this.#loadUpdated as SubscriptionObjectUpdated, this.group!);
+				}
+			
+			this.#loadUpdated = null;
+			
+			this.emit("load", this.value);
+			
+			this.#loadPromise.resolve(this);
+			
+			if (this.#unloadPromise.isFulfilled)
+				this.#unloadPromise = new StatefulPromise();
+		}
+		
+	}
+	
+	#init() {
+		
+		this.emit("init", this.value);
+		
+		this.#initPromise.resolve(this);
+		
+	}
+	
+	#unload() {
+		
+		if (this.handle)
+			switch (this.type) {
+				case "array":
+					(this.handle as SubscriptionHandle<"array">).call(this.group!, null, this.group!);
+					break;
+				case "map":
+					(this.handle as SubscriptionHandle<"map">).call(this.group!, null, this.group!);
+					break;
+				default:
+					(this.handle as SubscriptionHandle<"object">).call(this.group!, null, this.group!);
+			}
+		
+		this.emit("unload", this.value);
+		
+		this.#unloadPromise.resolve(this);
+		
+		if (this.#loadPromise.isFulfilled)
+			this.#loadPromise = new StatefulPromise();
+		
+	}
+	
+	loaded() {
+		return this.#loadPromise;
+	}
+	
+	inited() {
+		return this.#initPromise;
+	}
+	
+	unloaded() {
+		return this.#unloadPromise;
+	}
+	
+	subscribe() {
+		return this.value?.[subscribeSymbol]();
+	}
+	
+	unsubscribe() {
+		return this.value?.[unsubscribeSymbol]();
+	}
+	
+	renew(publicationName: Definition<T>["publicationName"], params: Definition<T>["params"]) {
+		return this.value?.[renewSymbol](publicationName, params);
+	}
+	
+	valueOf() {
+		return this.value;
+	}
+	
+	
+	static debounceLimit = 4;
+	
+	static {
+		
+		privates.itemLoad = <
+			DP extends Definition<TP>,
+			TP extends SubscriptionType
+		>(item: SubscriptionGroupItem<TP, DP>) => item.#load();
+		privates.itemInit = <
+			DP extends Definition<TP>,
+			TP extends SubscriptionType
+		>(item: SubscriptionGroupItem<TP, DP>) => item.#init();
+		privates.itemUnload = <
+			DP extends Definition<TP>,
+			TP extends SubscriptionType
+		>(item: SubscriptionGroupItem<TP, DP>) => item.#unload();
+		
+	}
+	
+}

package/src/SubscriptionGroup/common.ts

@@ -0,0 +1,13 @@
+import type { SubscriptionGroup } from "./SubscriptionGroup";
+import type { SubscriptionGroupItem } from "./SubscriptionGroupItem";
+import type { SubscriptionType } from "./types";
+
+
+export const privates: {
+	groupLoad?: (group: SubscriptionGroup) => void;
+	groupInit?: (group: SubscriptionGroup) => void;
+	groupUnload?: (group: SubscriptionGroup) => void;
+	itemLoad?: <T extends SubscriptionType>(item: SubscriptionGroupItem<T>) => void;
+	itemInit?: <T extends SubscriptionType>(item: SubscriptionGroupItem<T>) => void;
+	itemUnload?: <T extends SubscriptionType>(item: SubscriptionGroupItem<T>) => void;
+} = {};

package/src/SubscriptionGroup/index.ts

@@ -0,0 +1,8 @@
+export * from "./SubscriptionGroup";
+export {
+	Definition as SubscriptionGroupDefinition,
+	ParseValues as ParseSubscriptionGroupValues,
+	SubscriptionHandle as SubscriptionGroupSubscriptionHandle,
+	SubscriptionType as SubscriptionGroupSubscriptionType,
+	UnparsedDefinition as SubscriptionGroupUnparsedDefinition
+} from "./types";

package/src/SubscriptionGroup/types.ts

@@ -0,0 +1,121 @@
+import type {
+	SubscriptionArrayUpdated,
+	Updates as SubscriptionArrayUpdates,
+	SubscriptionArrayWithSubscription
+} from "../SubscriptionArray";
+import type {
+	SubscriptionMapUpdated,
+	Updates as SubscriptionMapUpdates,
+	SubscriptionMapWithSubscription
+} from "../SubscriptionMap";
+import type {
+	Updated as SubscriptionObjectUpdated,
+	Updates as SubscriptionObjectUpdates,
+	SubscriptionObjectWithSubscription
+} from "../SubscriptionObject";
+import type { SubscriptionGroup } from "./SubscriptionGroup";
+
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+
+export type SubscriptionType = "array" | "map" | "object";
+
+export type SubscriptionUpdated<T> =
+	T extends "array" ?
+		SubscriptionArrayUpdated<any> :
+		T extends "map" ?
+			SubscriptionMapUpdated<any> :
+			T extends "object" ?
+				SubscriptionObjectUpdated :
+				never;
+
+export type SubscriptionValue<T> =
+	T extends "array" ?
+		SubscriptionArrayWithSubscription<any> :
+		T extends "map" ?
+			SubscriptionMapWithSubscription<any> :
+			T extends "object" ?
+				SubscriptionObjectWithSubscription :
+				never;
+
+export type SubscriptionHandle<T> =
+	T extends "array" ?
+		(updated: null | SubscriptionArrayUpdated<any>, group: SubscriptionGroup) => void :
+		T extends "map" ?
+			(updated: null | SubscriptionMapUpdated<any>, group: SubscriptionGroup) => void :
+			T extends "object" ?
+				(updated: null | SubscriptionObjectUpdated, group: SubscriptionGroup) => void :
+				never;
+
+export type SubscriptionOnBeforeInit<T> =
+	T extends "array" ?
+		(value: SubscriptionArrayWithSubscription<any>) => void :
+		T extends "map" ?
+			(value: SubscriptionMapWithSubscription<any>) => void :
+			T extends "object" ?
+				(value: SubscriptionObjectWithSubscription) => void :
+				never;
+
+export type SubscriptionUpdates<T> =
+	T extends "array" ?
+		SubscriptionArrayUpdates :
+		T extends "map" ?
+			SubscriptionMapUpdates :
+			T extends "object" ?
+				SubscriptionObjectUpdates :
+				never;
+
+export type Definition<T extends SubscriptionType = SubscriptionType> = {
+	name: string;
+	value?: SubscriptionValue<T>;
+	type?: T;
+	publicationName?: string;
+	params?: unknown[];
+	handle?: (...args: any[]) => void;
+	onBeforeInit?: (...args: any[]) => void;
+	debounce?: number;
+	preventBind?: boolean;
+};
+
+export type TupleDefinition = unknown[];
+
+export type UnparsedDefinition<T extends SubscriptionType = SubscriptionType> = Definition<T> | TupleDefinition;
+
+type ResolveObjectValue<T> =
+	T extends { value: infer V } ? V :
+	T extends { type: "array" } ? SubscriptionArrayWithSubscription<any> :
+	T extends { type: "map" } ? SubscriptionMapWithSubscription<any> :
+	T extends { type: "object" } ? SubscriptionObjectWithSubscription :
+	SubscriptionObjectWithSubscription;
+
+type ResolveArrayValue<T extends any[]> =
+	T[1] extends object ? T[1] :
+	T[1] extends "array" ? SubscriptionArrayWithSubscription<any> :
+	T[1] extends "map" ? SubscriptionMapWithSubscription<any> :
+	T[1] extends "object" ? SubscriptionObjectWithSubscription :
+	SubscriptionObjectWithSubscription;
+
+type ResolveValue<U> =
+	U extends object ?
+		ResolveObjectValue<U> :
+		U extends any[] ?
+			ResolveArrayValue<U> :
+			never;
+
+export type ParseValues<T extends Array<any[] | object>> =
+	{
+		[K in keyof T as T[K] extends { name: infer N } ?
+			N extends string ?
+				N :
+				never :
+			T[K] extends [infer F, any] ?
+				F extends string ?
+					F :
+					never :
+				never
+		]: ResolveValue<T[K]>;
+	} &
+	T extends Array<infer U> ?
+		ResolveValue<U>[] :
+		never;