insite-subscriptions-client 1.0.294

package/lib/SubscriptionGroup/SubscriptionGroupItem.js

@@ -0,0 +1,300 @@
+import { debounce, removeOne } from "@nesvet/n";
+import EventEmitter from "eventemitter3";
+import { SubscriptionArray } from "../SubscriptionArray";
+import { SubscriptionMap } from "../SubscriptionMap";
+import { SubscriptionObject } from "../SubscriptionObject";
+import {
+	getAsInitialUpdatedSymbol,
+	getAsUpdatesSymbol,
+	getHandleUpdateSymbol,
+	renewSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol
+} from "../symbols";
+import { privates } from "./common";
+
+
+const SubscriptionValuesByType = {
+	object: SubscriptionObject,
+	array: SubscriptionArray,
+	map: SubscriptionMap
+};
+
+
+export class SubscriptionGroupItem extends EventEmitter {
+	constructor(definition, group) {
+		super();
+		
+		this.name = definition.name;
+		
+		this.define(definition, group);
+		
+	}
+	
+	isLoaded = false;
+	isInited = false;
+	
+	#loadPromise;
+	#initPromise;
+	#unloadPromise;
+	#loadResolve;
+	#initResolve;
+	#unloadResolve;
+	
+	define(definition, group = this.group) {
+		
+		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);
+		
+	}
+	
+	#applyOptions({ debounceLimit, preventBind }) {
+		
+		const 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;
+			let group;
+			
+			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 (Array.isArray(updated))
+						if (debouncedUpdated)
+							for (const item of updated)
+								debouncedUpdated.push(item);
+						else
+							debouncedUpdated = [ ...updated ];
+					else if (typeof updated == "object")
+						if (debouncedUpdated)
+							Object.assign(debouncedUpdated, updated);
+						else
+							debouncedUpdated = { ...updated };
+					else
+						debouncedUpdated = updated;
+				
+				({ group } = this);
+				
+				return emitUpdateDebounced();
+			};
+		} else
+			this.emitUpdate = emitUpdate;
+		
+		if (this.preventBind === undefined)
+			delete this.preventBind;
+		else
+			this.preventBind = preventBind;
+		
+	}
+	
+	#attachTo(group) {
+		this.group = group;
+		
+		this.group.items.push(this);
+		this.group.items[this.name] = this;
+		
+		if (!this.#loadPromise || this.#loadPromise.isResolved)
+			this.#loadPromise = new Promise(resolve => (this.#loadResolve = resolve));
+		
+		if (!this.#initPromise || this.#initPromise.isResolved)
+			this.#initPromise = new Promise(resolve => (this.#initResolve = resolve));
+		
+		if (!this.#unloadPromise || this.#unloadPromise.isResolved)
+			this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+		
+		if (this.value)
+			this.value[setHandleUpdateSymbol](this.#handleSubscription);
+		else
+			this.value = new SubscriptionValuesByType[this.type].WithSubscription(this.publicationName, this.params, this.#handleSubscription, false);
+		
+		this.group.values.push(this.value);
+		this.group.values[this.name] = this.value;
+		
+		this.onBeforeInit?.call(this.group, this.value);
+		
+	}
+	
+	detach() {
+		
+		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;
+	
+	#handleSubscription = (_, updated, updates) => {
+		if (updates)
+			if (this.group.isLoaded) {
+				this.handle?.call(this.group, updated, 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) {
+			this.handle?.call(this.group, this.#loadUpdated, this.group);
+			this.#loadUpdated = null;
+			
+			this.emit("load", this.value);
+			
+			this.#loadResolve(this);
+			this.#loadPromise.isResolved = true;
+			
+			if (this.#unloadPromise.isResolved)
+				this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+		}
+		
+	}
+	
+	#init() {
+		
+		this.emit("init", this.value);
+		
+		this.#initResolve(this);
+		this.#initPromise.isResolved = true;
+		
+	}
+	
+	#unload() {
+		
+		this.handle?.call(this.group, null, this.group);
+		
+		this.emit("unload", this.value);
+		
+		this.#unloadResolve(this);
+		this.#unloadPromise.isResolved = true;
+		
+		if (this.#loadPromise.isResolved)
+			this.#loadPromise = new Promise(resolve => (this.#loadResolve = resolve));
+		
+	}
+	
+	loaded() {
+		return this.#loadPromise;
+	}
+	
+	inited() {
+		return this.#initPromise;
+	}
+	
+	unloaded() {
+		return this.#unloadPromise;
+	}
+	
+	subscribe() {
+		return (
+			this.value[subscribeSymbol] ?
+				this.value[subscribeSymbol]() :
+				this.value[getHandleUpdateSymbol]()(this.value, this.value[getAsInitialUpdatedSymbol](), this.value[getAsUpdatesSymbol]())
+		);
+	}
+	
+	unsubscribe() {
+		return this.value[unsubscribeSymbol]?.();
+	}
+	
+	renew(publicationName, params) {
+		return this.value[renewSymbol]?.(publicationName, params);
+	}
+	
+	valueOf() {
+		return this.value;
+	}
+	
+	
+	static debounceLimit = 4;
+	
+	static {
+		
+		privates.itemLoad = item => item.#load();
+		privates.itemInit = item => item.#init();
+		privates.itemUnload = item => item.#unload();
+		
+	}
+	
+}

package/lib/SubscriptionGroup/common.js

@@ -0,0 +1 @@
+export const privates = {};

package/lib/SubscriptionGroup/index.js

@@ -0,0 +1 @@
+export * from "./SubscriptionGroup";

package/lib/SubscriptionMap.js

@@ -0,0 +1,393 @@
+import { removeOne } from "@nesvet/n";
+import { Subscription } from "./Subscription";
+import {
+	clearSymbol,
+	getAsInitialUpdatedSymbol,
+	getAsUpdatesSymbol,
+	getHandleUpdateSymbol,
+	getSubscriptionSymbol,
+	renewSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol,
+	updateSymbol
+} from "./symbols";
+
+
+function makeSort(sort) {
+	
+	const functionName = `function${performance.now().toString(36).replace(/\./g, "")}`;
+	
+	const tempScript = document.createElement("script");
+	tempScript.textContent = `window.${functionName} = function sort(a, b) { return ${`${Object.entries(sort).map(([ key, value ]) => value > 0 ? `a.${key} > b.${key} ? 1 : a.${key} < b.${key} ? -1 :` : `a.${key} < b.${key} ? 1 : a.${key} > b.${key} ? -1 :`).concat("0").join(" ")};`} }`;
+	document.head.append(tempScript);
+	tempScript.remove();
+	
+	const sortFunction = window[functionName];
+	
+	delete window[functionName];
+	
+	return sortFunction;
+}
+
+
+export class SubscriptionMap extends Map {
+	constructor(updates, onUpdate) {
+		super();
+		
+		if (onUpdate)
+			this.handleUpdate = onUpdate;
+		
+		if (updates)
+			this.update(updates);
+		
+	}
+	
+	#updates = new Map();
+	
+	sortList = null;
+	
+	sortCompareFunction = null;
+	
+	#fieldsToSort = [];
+	
+	sorted = [];
+	
+	sort() {
+		
+		this.sorted.sort(this.sortCompareFunction);
+		
+	}
+	
+	[getHandleUpdateSymbol]() {
+		return this.handleUpdate;
+	}
+	
+	[setHandleUpdateSymbol](handleUpdate) {
+		return (this.handleUpdate = handleUpdate);
+	}
+	
+	#Item;
+	
+	set Item(Item) {
+		this.#Item = Item;
+		
+		if (this.size)
+			for (const [ _id, item ] of this)
+				this.set(_id, new Item(this, item));
+		
+	}
+	
+	get Item() {
+		return this.#Item;
+	}
+	
+	update(updates) {
+		
+		const updated = [];
+		updated.added = [];
+		updated.deleted = [];
+		
+		if (updates) {
+			let shouldSort = false;
+			
+			const Item = this.#Item;
+			const prevUpdates = this.#updates;
+			
+			for (const update of updates)
+				switch (update?.[0]) {
+					case "i"/* initial */: {
+						const [ , array, sort ] = update;
+						
+						if (sort) {
+							this.sortList = sort;
+							this.sortCompareFunction = makeSort(sort);
+							this.#fieldsToSort = [ ...new Set(Object.keys(sort).map(key => key.replace(/\..+/, ""))) ];
+							shouldSort = true;
+						} else {
+							this.sortList = null;
+							this.sortCompareFunction = null;
+							this.#fieldsToSort = [];
+						}
+						
+						if (this.size) {
+							const updatesMap = new Map();
+							for (const itemUpdates of array)
+								updatesMap.set(itemUpdates._id, itemUpdates);
+							
+							for (const [ _id, item ] of this) {
+								const itemUpdates = updatesMap.get(_id);
+								if (itemUpdates) {
+									const prevItemUpdates = prevUpdates.get(_id);
+									
+									if (Item)
+										item.update(itemUpdates);
+									else {
+										for (const key in prevItemUpdates)
+											delete item[key];
+										
+										Object.assign(item, itemUpdates);
+									}
+									
+									prevUpdates.set(_id, itemUpdates);
+									updated.push(item);
+									updatesMap.delete(_id);
+								} else {
+									if (Item)
+										item.delete();
+									else
+										this.delete(_id);
+									prevUpdates.delete(_id);
+									updated.deleted.push(_id);
+								}
+							}
+							
+							for (const [ _id, itemUpdates ] of updatesMap) {
+								const item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+								this.set(_id, item);
+								prevUpdates.set(_id, itemUpdates);
+								updated.push(item);
+								updated.added.push(item);
+							}
+							
+							if (this.sortList)
+								this.sorted = array.map(newItem => this.get(newItem._id));
+							
+						} else
+							for (const itemUpdates of array) {
+								const item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+								this.set(item._id, item);
+								this.sorted.push(item);
+								prevUpdates.set(item._id, itemUpdates);
+								updated.push(item);
+								updated.added.push(item);
+							}
+						
+						break;
+					}
+					
+					case "c"/* create */:
+					case "u"/* update */: {
+						let itemUpdates = update[1];
+						let item = this.get(itemUpdates._id);
+						
+						if (item) {
+							const isAtomic = update[2] === true;
+							const updatedFields = isAtomic ? Object.keys(itemUpdates) : update[2];
+							const prevItemUpdates = prevUpdates.get(item._id);
+							
+							if (Item)
+								item.update(itemUpdates);
+							else {
+								if (!isAtomic)
+									for (const key in prevItemUpdates)
+										delete item[key];
+								
+								Object.assign(item, itemUpdates);
+							}
+							
+							if (isAtomic)
+								itemUpdates = Object.assign(prevItemUpdates, itemUpdates);
+							
+							if (this.sortList && !shouldSort && (!updatedFields || updatedFields.some(fieldName => this.#fieldsToSort.includes(fieldName))))
+								shouldSort = true;
+						} else {
+							item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+							this.set(item._id, item);
+							this.sorted.push(item);
+							if (this.sortList)
+								shouldSort = true;
+							updated.added.push(item);
+						}
+						
+						prevUpdates.set(item._id, itemUpdates);
+						updated.push(item);
+						
+						break;
+					}
+					
+					case "d"/* delete */: {
+						const _id = update[1];
+						const itemToDelete = this.get(_id);
+						
+						if (itemToDelete) {
+							if (Item)
+								itemToDelete.delete();
+							else
+								this.delete(_id);
+							prevUpdates.delete(_id);
+							removeOne(this.sorted, itemToDelete);
+							updated.deleted.push(_id);
+						}
+						
+						break;
+					}
+					
+					default:
+						this.clear();
+				}
+			
+			if (shouldSort)
+				this.sort();
+			
+		} else
+			this.clear();
+		
+		this.handleUpdate?.(this, updated, updates?.[0] && updates);
+		
+		return this;
+	}
+	
+	[updateSymbol] = this.update;
+	
+	getAsUpdates() {
+		return (
+			(this.size || this.sortList) ?
+				[ [ "i"/* initial */, [ ...this.#updates.values() ], this.sortList ] ] :
+				null
+		);
+	}
+	
+	[getAsUpdatesSymbol] = this.getAsUpdates;
+	
+	getAsInitialUpdated() {
+		return Object.assign([ ...this.sorted ], {
+			added: [ ...this.sorted ],
+			deleted: []
+		});
+	}
+	
+	[getAsInitialUpdatedSymbol] = this.getAsInitialUpdated;
+	
+	clear() {
+		
+		super.clear();
+		this.#updates.clear();
+		this.sorted = [];
+		this.sortList = null;
+		this.sortCompareFunction = null;
+		this.#fieldsToSort = [];
+		
+	}
+	
+	[clearSymbol] = this.clear;
+	
+	valueOf() {
+		return this.sorted;
+	}
+	
+	get [Symbol.toStringTag]() {
+		return "SubscriptionMap";
+	}
+	
+	
+	static updateSymbol = updateSymbol;
+	static getHandleUpdateSymbol = getHandleUpdateSymbol;
+	static setHandleUpdateSymbol = setHandleUpdateSymbol;
+	static getAsUpdatesSymbol = getAsUpdatesSymbol;
+	static getAsInitialUpdatedSymbol = getAsInitialUpdatedSymbol;
+	static clearSymbol = clearSymbol;
+	
+}
+
+
+SubscriptionMap.WithSubscription = class SubscriptionMapWithSubscription extends SubscriptionMap {
+	constructor(publicationName, params, onUpdate, immediately = true) {
+		super(null, onUpdate);
+		
+		this.publicationName = publicationName;
+		this.params = params;
+		
+		if (immediately)
+			this.subscribe();
+		
+	}
+	
+	subscription = null;
+	
+	subscribe() {
+		
+		if (!this.subscription)
+			this.subscription = new Subscription("map", this.publicationName, this.params, updates => this.update(updates));
+		
+	}
+	
+	get [subscribeSymbol]() {
+		return this.subscribe;
+	}
+	
+	unsubscribe() {
+		
+		if (this.subscription) {
+			this.subscription.cancel();
+			this.subscription = null;
+		}
+		
+	}
+	
+	get [unsubscribeSymbol]() {
+		return this.unsubscribe;
+	}
+	
+	renew(publicationName, params) {
+		
+		if (this.subscription) {
+			this.unsubscribe();
+			
+			if (publicationName)
+				if (Array.isArray(publicationName))
+					params = publicationName;
+				else
+					this.publicationName = publicationName;
+			
+			if (params)
+				this.params = params;
+			
+			this.subscribe();
+		}
+		
+	}
+	
+	get [renewSymbol]() {
+		return this.renew;
+	}
+	
+	[getSubscriptionSymbol]() {
+		return this.subscription;
+	}
+	
+	get [Symbol.toStringTag]() {
+		return "SubscriptionMapWithSubscription";
+	}
+	
+	
+	static subscribeSymbol = subscribeSymbol;
+	static unsubscribeSymbol = unsubscribeSymbol;
+	static renewSymbol = renewSymbol;
+	static getSubscriptionSymbol = getSubscriptionSymbol;
+	
+};
+
+
+SubscriptionMap.Item = class SubscriptionMapItem {
+	constructor(map, updates) {
+		this.#map = map;
+		
+		this.update(updates);
+		
+	}
+	
+	#map;
+	
+	update(updates) {
+		Object.assign(this, updates);
+		
+	}
+	
+	delete() {
+		
+		this.#map.delete(this._id);
+		
+	}
+	
+};