insite-subscriptions-client 2.0.0 → 2.0.1

package/src/SubscriptionGroup/SubscriptionGroup.ts

@@ -1,319 +0,0 @@
-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";
-
-
-/* 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: Partial<Definition<T>> = {};
-		
-		parsed.name = args.shift() as Definition<T>["name"];
-		if (typeof args[0] == "object" && !Array.isArray(args[0])) {
-			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() as Definition<T>["type"];
-			if (typeof args[0] == "string")
-				parsed.publicationName = args.shift() as Definition<T>["publicationName"];
-			if (Array.isArray(args[0]))
-				parsed.params = args.shift() as Definition<T>["params"];
-		}
-		
-		if (typeof args[0] == "function")
-			parsed.handle = args.shift() as SubscriptionHandle<T>;
-		if (typeof args[0] == "function")
-			parsed.onBeforeInit = args.shift() as SubscriptionOnBeforeInit<T>;
-		if (typeof args[0] == "number")
-			parsed.debounce = args.shift() as Definition<T>["debounce"];
-		if (typeof args[0] == "boolean")
-			parsed.preventBind = args.shift() as Definition<T>["preventBind"];
-		
-		return parsed as Definition<T>;
-	}
-	
-	definition.type ??= "object" as T;
-	
-	return definition;
-}
-
-export class SubscriptionGroup<DS extends UnparsedDefinition[] = any[]> extends EventEmitter {
-	constructor(
-		definitions: DS,
-		{
-			target,
-			debounce: debounceLimit = SubscriptionGroup.debounceLimit,
-			immediately
-		}: Options = {}
-	) {
-		super();
-		
-		this.applyOptions({ target, debounceLimit });
-		
-		this.#initPromise = new StatefulPromise();
-		
-		this.attach(definitions, false, immediately);
-		
-	}
-	
-	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!: StatefulPromise<SubscriptionGroup>;
-	#initPromise: StatefulPromise<SubscriptionGroup>;
-	#unloadPromise!: StatefulPromise<SubscriptionGroup>;
-	
-	#debounceLimit?: null | number = null;
-	
-	applyOptions({ target, debounceLimit }: { target?: Target; debounceLimit?: number }) {
-		
-		if (this.target !== target) {
-			if (this.target)
-				for (const item of this.items)
-					if (item.isLoaded && !item.preventBind)
-						delete this.target[item.name];
-			
-			this.target = target;
-			
-			if (this.target)
-				for (const item of this.items)
-					if (item.isLoaded && !item.preventBind)
-						this.target[item.name] = item.value;
-		}
-		
-		if (this.#debounceLimit !== debounceLimit) {
-			this.#debounceLimit = debounceLimit;
-			if (typeof this.#debounceLimit == "number") {
-				const emitUpdateDebounced = debounce(() => this.emit("update", this.values), this.#debounceLimit);
-				this.emitUpdate = () => emitUpdateDebounced();
-			} else
-				this.emitUpdate = () => this.emit("update", this.values);
-		}
-		
-	}
-	
-	attach(definitions: DS, shouldReload = this.isLoaded, immediately = true) {
-		if (shouldReload)
-			this.isLoaded = false;
-		
-		if (!this.#loadPromise || this.#loadPromise.isFulfilled)
-			this.#loadPromise = new StatefulPromise();
-		
-		if (!this.#unloadPromise || this.#unloadPromise.isFulfilled)
-			this.#unloadPromise = new StatefulPromise();
-		
-		return Promise.all(definitions.map(definition =>
-			new SubscriptionGroupItem(parseDefinition(definition), this)
-		).map(item => {
-			
-			if (immediately)
-				item.subscribe();
-			
-			return item.loaded();
-		}));
-	}
-	
-	detach(names: string[], shouldUpdate = true) {
-		
-		for (const name of names)
-			this.items[name]?.detach();
-		
-		if (shouldUpdate) {
-			this.#unload();
-			this.#load();
-		}
-		
-	}
-	
-	redefine(definitions: DS) {
-		
-		const itemsToDetach = new Map(this.items.map(item => [ item.name, item ]));
-		const definitionsToRedefine = [];
-		const definitionsToAttach = [] as unknown as DS;
-		
-		for (let definition of definitions) {
-			definition = parseDefinition(definition);
-			if (itemsToDetach.delete(definition.name))
-				definitionsToRedefine.push(definition);
-			else
-				definitionsToAttach.push(definition);
-		}
-		
-		this.isLoaded = false;
-		
-		this.detach([ ...itemsToDetach.keys() ], false);
-		
-		return Promise.all([
-			...definitionsToRedefine.map(definition => {
-				const item = this.items[definition.name];
-				item.define(definition);
-				
-				item.subscribe();
-				
-				return item.loaded();
-			}),
-			...definitionsToAttach.length ? [ this.attach(definitionsToAttach, false) ] : []
-		]);
-	}
-	
-	subscribe() {
-		return this.items.map(item => item.subscribe());
-	}
-	
-	unsubscribe() {
-		return this.items.map(item => item.unsubscribe());
-	}
-	
-	#load() {
-		
-		if (!this.isLoaded && this.items.every(item => item.isLoaded)) {
-			if (this.target)
-				for (const item of this.items)
-					if (!item.preventBind)
-						this.target[item.name] = item.value;
-			
-			this.isLoaded = true;
-			
-			for (const item of this.items)
-				privates.itemLoad!(item);
-			
-			this.emit("load", this.values);
-			
-			if (this.isInited)
-				if (this.items.length)
-					for (const item of this.items)
-						item.emitUpdate();
-				else
-					this.emitUpdate();
-			
-			
-			this.#loadPromise.resolve(this);
-			
-			if (this.#unloadPromise.isFulfilled)
-				this.#unloadPromise = new StatefulPromise();
-		}
-		
-	}
-	
-	#init() {
-		
-		if (!this.isInited && this.items.every(item => item.isInited)) {
-			this.isInited = true;
-			
-			if (this.isLoaded)
-				if (this.items.length)
-					for (const item of this.items)
-						item.emitUpdate();
-				else
-					this.emitUpdate();
-			
-			
-			for (const item of this.items)
-				privates.itemInit!(item);
-			
-			this.emit("init", this.values);
-			
-			this.#initPromise.resolve(this);
-		}
-		
-	}
-	
-	#unload() {
-		
-		if (this.isLoaded && this.items.every(item => !item.isLoaded)) {
-			if (this.target)
-				for (const item of this.items)
-					if (!item.preventBind)
-						delete this.target[item.name];
-			
-			this.isLoaded = false;
-			
-			for (const item of this.items)
-				privates.itemUnload!(item);
-			
-			this.emit("unload", this.values);
-			
-			if (this.items.length)
-				for (const item of this.items)
-					item.emitUpdate();
-			else
-				this.emitUpdate();
-			
-			this.#unloadPromise.resolve(this);
-			
-			if (this.#loadPromise.isFulfilled)
-				this.#loadPromise = new StatefulPromise();
-		}
-		
-	}
-	
-	loaded() {
-		return this.#loadPromise;
-	}
-	
-	inited() {
-		return this.#initPromise;
-	}
-	
-	unloaded() {
-		return this.#unloadPromise;
-	}
-	
-	valueOf() {
-		return this.values;
-	}
-	
-	[Symbol.iterator]() {
-		return this.values[Symbol.iterator]();
-	}
-	
-	
-	static debounceLimit = 8;
-	
-	static {
-		
-		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 };

package/src/SubscriptionGroup/SubscriptionGroupItem.ts

@@ -1,391 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-} = {};