insite-subscriptions-client 1.0.294

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Eugene Nesvetaev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# inSite subscriptions client side
+
+## Installation
+
+```sh
+$ npm install insite-subscriptions-client
+```
+
+Or
+
+```sh
+$ yarn add insite-subscriptions-client
+```

package/lib/Subscription.js

@@ -0,0 +1,106 @@
+//#if _SSR
+// import { publications } from "insite-subscriptions-server";
+
+
+// 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);
+
+// }
+
+
+//#else
+let i, subscriptions, ws;
+
+export class Subscription {
+	constructor(type, publicationName, args = [], handler, immediately = true) {
+		
+		if (!ws)
+			throw new Error("Subscription is not binded to WS. Do Subscription.bindTo(ws) first");
+		
+		this.i = i++;
+		this.type = type;
+		this.publicationName = publicationName;
+		this.args = args;
+		this.handler = handler;
+		this.immediately = immediately && !window.__initials;
+		
+		subscriptions.set(this.i, this);
+		
+		ws.on("open", this.start);
+		
+		if (ws.isOpen)
+			this.start();
+		
+		if (window.__initials) {
+			this.isActive = true;
+			this.handler(window.__initials.splice(0, 1)[0]);
+		} else
+			this.isActive = false;
+		
+	}
+	
+	start = () => {
+		
+		ws.sendMessage("s-s"/* subscription subscribe */, this.type, this.publicationName, this.i, this.args, this.immediately);
+		
+		this.immediately = true;
+		
+	};
+	
+	cancel() {
+		
+		subscriptions.delete(this.i);
+		
+		ws.off("open", this.start);
+		
+		ws.sendMessage("s-u"/* subscription unsubscribe */, this.i);
+		
+	}
+	
+	
+	static bindTo(_ws) {
+		ws = _ws;
+		
+		i = 0;
+		
+		subscriptions =
+			Subscription.subscriptions =
+				new Map();
+		
+		ws.on("message:s-c"/* subscription changed */, (_i, data) => {
+			const subscription = subscriptions.get(_i);
+			if (subscription) {
+				subscription.isActive = true;
+				subscription.handler(data);
+			}
+			
+		});
+		
+		ws.on("close", () => {
+			
+			for (const subscription of subscriptions.values())
+				subscription.isActive = false;
+			
+		});
+		
+		ws.on("server-change", () => {
+			
+			for (const subscription of subscriptions.values())
+				subscription.handler(null);
+			
+		});
+		
+	}
+	
+}
+
+
+//#endif

package/lib/SubscriptionArray.js

@@ -0,0 +1,241 @@
+import { removeOne } from "@nesvet/n";
+import { Subscription } from "./Subscription";
+import {
+	clearSymbol,
+	getAsInitialUpdatedSymbol,
+	getAsUpdatesSymbol,
+	getHandleUpdateSymbol,
+	getSubscriptionSymbol,
+	renewSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol,
+	updateSymbol
+} from "./symbols";
+
+
+const ascSort = (a, b) => a > b ? 1 : a < b ? -1 : 0;
+const descSort = (a, b) => a > b ? -1 : a < b ? 1 : 0;
+
+
+export class SubscriptionArray extends Array {
+	constructor(updates, onUpdate) {
+		super();
+		
+		this.handleUpdate = onUpdate;
+		
+		if (Array.isArray(updates))
+			this.update(updates);
+		
+	}
+	
+	sortDirection = 0;
+	
+	sortCompareFunction = null;
+	
+	[getHandleUpdateSymbol]() {
+		return this.handleUpdate;
+	}
+	
+	[setHandleUpdateSymbol](handleUpdate) {
+		return (this.handleUpdate = handleUpdate);
+	}
+	
+	update(updates) {
+		
+		const updated = [];
+		updated.deleted = [];
+		updated.added = [];
+		
+		if (updates) {
+			let shouldSort = false;
+			
+			for (const update of updates)
+				switch (update?.[0]) {
+					case "i"/* initial */: {
+						const [ , array, sort ] = update;
+						
+						if (sort) {
+							this.sortDirection = sort;
+							this.sortCompareFunction = sort > 0 ? ascSort : descSort;
+							shouldSort = true;
+						} else {
+							this.sortDirection = 0;
+							this.sortCompareFunction = null;
+						}
+						
+						this.length = 0;
+						
+						for (const newItem of array) {
+							this.push(newItem);
+							updated.push(newItem);
+							updated.added.push(newItem);
+						}
+						
+						break;
+					}
+					
+					case "a"/* add */: {
+						const newItem = update[1];
+						
+						if (!this.includes(newItem)) {
+							this.push(newItem);
+							if (this.sortDirection)
+								shouldSort = true;
+							updated.push(newItem);
+							updated.added.push(newItem);
+						}
+						
+						break;
+					}
+					
+					case "d"/* delete */: {
+						const itemToDelete = update[1];
+						
+						if (removeOne(this, itemToDelete))
+							updated.deleted.push(itemToDelete);
+						
+						break;
+					}
+					
+					default:
+						this.clear();
+				}
+			
+			if (shouldSort)
+				this.sort(this.sortCompareFunction);
+			
+		} else
+			this.clear();
+		
+		this.handleUpdate?.(this, updated, updates?.[0] && updates);
+		
+		return this;
+	}
+	
+	[updateSymbol] = this.update;
+	
+	getAsUpdates() {
+		return (
+			(this.length || this.sortDirection) ?
+				[ [ "i"/* initial */, [ ...this ], this.sortDirection ] ] :
+				null
+		);
+	}
+	
+	[getAsUpdatesSymbol] = this.getAsUpdates;
+	
+	getAsInitialUpdated() {
+		return Object.assign([ ...this.sorted ], {
+			added: [ ...this.sorted ],
+			deleted: []
+		});
+	}
+	
+	[getAsInitialUpdatedSymbol] = this.getAsInitialUpdated;
+	
+	clear() {
+		
+		this.length = 0;
+		this.sortDirection = 0;
+		this.sortCompareFunction = null;
+		
+	}
+	
+	[clearSymbol] = this.clear;
+	
+	valueOf() {
+		return this;
+	}
+	
+	get [Symbol.toStringTag]() {
+		return "SubscriptionArray";
+	}
+	
+	
+	static updateSymbol = updateSymbol;
+	static getHandleUpdateSymbol = getHandleUpdateSymbol;
+	static setHandleUpdateSymbol = setHandleUpdateSymbol;
+	static getAsUpdatesSymbol = getAsUpdatesSymbol;
+	static getAsInitialUpdatedSymbol = getAsInitialUpdatedSymbol;
+	static clearSymbol = clearSymbol;
+	
+}
+
+
+SubscriptionArray.WithSubscription = class SubscriptionArrayWithSubscription extends SubscriptionArray {
+	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("array", 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 "SubscriptionArrayWithSubscription";
+	}
+	
+	
+	static subscribeSymbol = subscribeSymbol;
+	static unsubscribeSymbol = unsubscribeSymbol;
+	static renewSymbol = renewSymbol;
+	static getSubscriptionSymbol = getSubscriptionSymbol;
+	
+};

package/lib/SubscriptionGroup/SubscriptionGroup.js

@@ -0,0 +1,292 @@
+import { debounce } from "@nesvet/n";
+import EventEmitter from "eventemitter3";
+import { privates } from "./common";
+import { SubscriptionGroupItem } from "./SubscriptionGroupItem";
+
+
+function parseDefinition(definition) {
+	if (Array.isArray(definition)) {
+		const args = definition.slice();
+		
+		const parsed = {};
+		
+		parsed.name = args.shift();
+		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
+				throw new Error("Unknown value type");
+		} else {
+			if (typeof args[0] == "string")
+				parsed.type = args.shift();
+			if (typeof args[0] == "string")
+				parsed.publicationName = args.shift();
+			if (Array.isArray(args[0]))
+				parsed.params = args.shift();
+		}
+		if (typeof args[0] == "function")
+			parsed.handle = args.shift();
+		if (typeof args[0] == "function")
+			parsed.onBeforeInit = args.shift();
+		if (typeof args[0] == "number")
+			parsed.debounceLimit = args.shift();
+		if (typeof args[0] == "boolean")
+			parsed.preventBind = args.shift();
+		
+		return parsed;
+	}
+	
+	return definition;
+}
+
+export class SubscriptionGroup extends EventEmitter {
+	constructor(definitions, options = {}) {
+		super();
+		
+		const {
+			target,
+			debounce: debounceLimit = SubscriptionGroup.debounceLimit,
+			immediately
+		} = options;
+		
+		this.#applyOptions({ target, debounceLimit });
+		
+		this.#initPromise = new Promise(resolve => (this.#initResolve = resolve));
+		
+		this.attach(definitions, false, immediately);
+		
+	}
+	
+	items = [];
+	values = [];
+	
+	isLoaded = false;
+	isInited = false;
+	
+	#loadPromise;
+	#initPromise;
+	#unloadPromise;
+	#loadResolve;
+	#initResolve;
+	#unloadResolve;
+	
+	#debounceLimit = null;
+	
+	#applyOptions({ target, debounceLimit }) {
+		
+		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, 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.#unloadPromise || this.#unloadPromise.isResolved)
+			this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+		
+		return Promise.all(definitions.map(definition =>
+			new SubscriptionGroupItem(parseDefinition(definition), this)
+		).map(item => {
+			
+			if (immediately)
+				item.subscribe();
+			
+			return item.loaded();
+		}));
+	}
+	
+	detach(names, shouldUpdate = true) {
+		
+		for (const name of names)
+			this.items[name]?.detach();
+		
+		if (shouldUpdate) {
+			this.#unload();
+			this.#load();
+		}
+		
+	}
+	
+	redefine(definitions) {
+		
+		const itemsToDetach = new Map(this.items.map(item => [ item.name, item ]));
+		const definitionsToRedefine = [];
+		const definitionsToAttach = [];
+		
+		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.#loadResolve(this);
+			this.#loadPromise.isResolved = true;
+			
+			if (this.#unloadPromise.isResolved)
+				this.#unloadPromise = new Promise(resolve => (this.#unloadResolve = resolve));
+		}
+		
+	}
+	
+	#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.#initResolve(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.#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;
+	}
+	
+	valueOf() {
+		return this.values;
+	}
+	
+	[Symbol.iterator]() {
+		return this.values[Symbol.iterator]();
+	}
+	
+	
+	static debounceLimit = 8;
+	
+	static {
+		
+		privates.groupLoad = group => group.#load();
+		privates.groupInit = group => group.#init();
+		privates.groupUnload = group => group.#unload();
+		
+	}
+	
+}