insite-subscriptions-client 1.0.294 → 2.0.0

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

@@ -14,25 +14,70 @@ import {
 } from "./symbols";
 
 
-function makeSort(sort) {
-	
-	const functionName = `function${performance.now().toString(36).replace(/\./g, "")}`;
+type GenericItem = { _id: string } & Record<string, any>;// eslint-disable-line @typescript-eslint/no-explicit-any
+
+type Item = GenericItem | SubscriptionMapItem;
+
+type Updated<I extends Item = Item> = {
+	deleted: string[];
+	added: I[];
+} & I[];
+
+type SortList = Record<string, -1 | 1>;
+
+export type Updates<I extends Item = Item> =
+	(
+		[ "c"/* create */, item: I ] |
+		[ "d"/* delete */, _id: string ] |
+		[ "i"/* initial */, items: I[], sortList?: SortList ] |
+		[ "u"/* update */, itemUpdates: { _id: string } & Partial<I>, isAtomicOrUpdatedFields: string[] | true ] |
+		null
+	)[] |
+	null;
+
+type UpdateHandler<I extends Item = Item> = (map: SubscriptionMap<I>, updated: Updated<I>, updates: Updates<I>) => void;
+
+declare global {
+	var __insite_subscription_map_sort_function: ((a: Item, b: Item) => -1 | 0 | 1) | undefined;// eslint-disable-line no-var
+}
+
+function createSortFunction(sortList: SortList) {
 	
 	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(" ")};`} }`;
+	
+	tempScript.textContent = `window.__insite_subscription_map_sort_function = function sort(a, b) { return ${
+		Object.entries(sortList)
+			.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];
+	const sortFunction = window.__insite_subscription_map_sort_function!;
 	
-	delete window[functionName];
+	tempScript.remove();
+	delete window.__insite_subscription_map_sort_function;
 	
 	return sortFunction;
 }
 
+// function createSortFunction(sortList: SortList) {
+//     return new Function(// eslint-disable-line no-new-func
+// 		"a"/* Item */,
+// 		"b"/* Item */,
+// 		`return ${
+// 			Object.entries(sortList)
+// 				.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(" ")
+// 		}`
+// 	) as (a: Item, b: Item) => -1 | 0 | 1;
+// }
+
 
-export class SubscriptionMap extends Map {
-	constructor(updates, onUpdate) {
+export class SubscriptionMap<I extends Item = Item> extends Map<string, I> {
+	constructor(updates?: Updates<I>, onUpdate?: UpdateHandler<I>) {
 		super();
 		
 		if (onUpdate)
@@ -43,19 +88,22 @@ export class SubscriptionMap extends Map {
 		
 	}
 	
-	#updates = new Map();
+	handleUpdate;
+	
+	private updates = new Map();
 	
-	sortList = null;
+	sortList: null | SortList = null;
 	
-	sortCompareFunction = null;
+	sortCompareFunction: ((a: I, b: I) => number) | null = null;
 	
-	#fieldsToSort = [];
+	private fieldsToSort: string[] = [];
 	
-	sorted = [];
+	sorted: I[] = [];
 	
 	sort() {
 		
-		this.sorted.sort(this.sortCompareFunction);
+		if (this.sortCompareFunction)
+			this.sorted.sort(this.sortCompareFunction);
 		
 	}
 	
@@ -63,51 +111,52 @@ export class SubscriptionMap extends Map {
 		return this.handleUpdate;
 	}
 	
-	[setHandleUpdateSymbol](handleUpdate) {
+	[setHandleUpdateSymbol](handleUpdate: UpdateHandler<I>) {
 		return (this.handleUpdate = handleUpdate);
 	}
 	
-	#Item;
+	private TheItem!: { new (map: SubscriptionMap<I>, updates: GenericItem): I };
 	
-	set Item(Item) {
-		this.#Item = Item;
+	set Item(TheItem: { new (map: SubscriptionMap<I>, updates: GenericItem): I }) {
+		this.TheItem = TheItem;
 		
 		if (this.size)
 			for (const [ _id, item ] of this)
-				this.set(_id, new Item(this, item));
+				this.set(_id, new TheItem(this, item));
 		
 	}
 	
 	get Item() {
-		return this.#Item;
+		return this.TheItem;
 	}
 	
-	update(updates) {
+	update(updates: Updates<I>) {
 		
-		const updated = [];
-		updated.added = [];
-		updated.deleted = [];
+		const updated: Updated<I> = Object.assign([], {
+			added: [],
+			deleted: []
+		});
 		
 		if (updates) {
 			let shouldSort = false;
 			
-			const Item = this.#Item;
-			const prevUpdates = this.#updates;
+			const TheItem = this.TheItem;// eslint-disable-line prefer-destructuring
+			const prevUpdates = this.updates;
 			
 			for (const update of updates)
 				switch (update?.[0]) {
 					case "i"/* initial */: {
-						const [ , array, sort ] = update;
+						const [ , array, sortList ] = update;
 						
-						if (sort) {
-							this.sortList = sort;
-							this.sortCompareFunction = makeSort(sort);
-							this.#fieldsToSort = [ ...new Set(Object.keys(sort).map(key => key.replace(/\..+/, ""))) ];
+						if (sortList) {
+							this.sortList = sortList;
+							this.sortCompareFunction = createSortFunction(sortList);
+							this.fieldsToSort = [ ...new Set(Object.keys(sortList).map(key => key.replace(/\..+/, ""))) ];
 							shouldSort = true;
 						} else {
 							this.sortList = null;
 							this.sortCompareFunction = null;
-							this.#fieldsToSort = [];
+							this.fieldsToSort = [];
 						}
 						
 						if (this.size) {
@@ -120,11 +169,11 @@ export class SubscriptionMap extends Map {
 								if (itemUpdates) {
 									const prevItemUpdates = prevUpdates.get(_id);
 									
-									if (Item)
+									if (TheItem)
 										item.update(itemUpdates);
 									else {
-										for (const key in prevItemUpdates)
-											delete item[key];
+										for (const key in prevItemUpdates)// eslint-disable-line guard-for-in
+											delete item[key as keyof typeof item];
 										
 										Object.assign(item, itemUpdates);
 									}
@@ -133,7 +182,7 @@ export class SubscriptionMap extends Map {
 									updated.push(item);
 									updatesMap.delete(_id);
 								} else {
-									if (Item)
+									if (TheItem)
 										item.delete();
 									else
 										this.delete(_id);
@@ -143,7 +192,7 @@ export class SubscriptionMap extends Map {
 							}
 							
 							for (const [ _id, itemUpdates ] of updatesMap) {
-								const item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+								const item = TheItem ? new TheItem(this, itemUpdates) : { ...itemUpdates };
 								this.set(_id, item);
 								prevUpdates.set(_id, itemUpdates);
 								updated.push(item);
@@ -151,11 +200,11 @@ export class SubscriptionMap extends Map {
 							}
 							
 							if (this.sortList)
-								this.sorted = array.map(newItem => this.get(newItem._id));
+								this.sorted = array.map(newItem => this.get(newItem._id)!);
 							
 						} else
 							for (const itemUpdates of array) {
-								const item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+								const item = (TheItem ? new TheItem(this, itemUpdates) : { ...itemUpdates }) as I;
 								this.set(item._id, item);
 								this.sorted.push(item);
 								prevUpdates.set(item._id, itemUpdates);
@@ -168,20 +217,20 @@ export class SubscriptionMap extends Map {
 					
 					case "c"/* create */:
 					case "u"/* update */: {
-						let itemUpdates = update[1];
+						let [ , itemUpdates ] = update;
 						let item = this.get(itemUpdates._id);
 						
 						if (item) {
 							const isAtomic = update[2] === true;
-							const updatedFields = isAtomic ? Object.keys(itemUpdates) : update[2];
+							const updatedFields = isAtomic ? Object.keys(itemUpdates) : update[2] as string[];
 							const prevItemUpdates = prevUpdates.get(item._id);
 							
-							if (Item)
+							if (TheItem)
 								item.update(itemUpdates);
 							else {
 								if (!isAtomic)
-									for (const key in prevItemUpdates)
-										delete item[key];
+									for (const key in prevItemUpdates)// eslint-disable-line guard-for-in
+										delete item[key as keyof typeof item];
 								
 								Object.assign(item, itemUpdates);
 							}
@@ -189,10 +238,10 @@ export class SubscriptionMap extends Map {
 							if (isAtomic)
 								itemUpdates = Object.assign(prevItemUpdates, itemUpdates);
 							
-							if (this.sortList && !shouldSort && (!updatedFields || updatedFields.some(fieldName => this.#fieldsToSort.includes(fieldName))))
+							if (this.sortList && !shouldSort && (!updatedFields || updatedFields.some(fieldName => this.fieldsToSort.includes(fieldName))))
 								shouldSort = true;
 						} else {
-							item = Item ? new Item(this, itemUpdates) : { ...itemUpdates };
+							item = (TheItem ? new TheItem(this, itemUpdates) : { ...itemUpdates }) as I;
 							this.set(item._id, item);
 							this.sorted.push(item);
 							if (this.sortList)
@@ -207,11 +256,11 @@ export class SubscriptionMap extends Map {
 					}
 					
 					case "d"/* delete */: {
-						const _id = update[1];
+						const [ , _id ] = update;
 						const itemToDelete = this.get(_id);
 						
 						if (itemToDelete) {
-							if (Item)
+							if (TheItem)
 								itemToDelete.delete();
 							else
 								this.delete(_id);
@@ -233,7 +282,7 @@ export class SubscriptionMap extends Map {
 		} else
 			this.clear();
 		
-		this.handleUpdate?.(this, updated, updates?.[0] && updates);
+		this.handleUpdate?.(this, updated, updates?.[0] ? updates : null);
 		
 		return this;
 	}
@@ -243,7 +292,7 @@ export class SubscriptionMap extends Map {
 	getAsUpdates() {
 		return (
 			(this.size || this.sortList) ?
-				[ [ "i"/* initial */, [ ...this.#updates.values() ], this.sortList ] ] :
+				[ [ "i"/* initial */, [ ...this.updates.values() ], this.sortList ] ] :
 				null
 		);
 	}
@@ -262,11 +311,11 @@ export class SubscriptionMap extends Map {
 	clear() {
 		
 		super.clear();
-		this.#updates.clear();
+		this.updates.clear();
 		this.sorted = [];
 		this.sortList = null;
 		this.sortCompareFunction = null;
-		this.#fieldsToSort = [];
+		this.fieldsToSort = [];
 		
 	}
 	
@@ -287,12 +336,14 @@ export class SubscriptionMap extends Map {
 	static getAsUpdatesSymbol = getAsUpdatesSymbol;
 	static getAsInitialUpdatedSymbol = getAsInitialUpdatedSymbol;
 	static clearSymbol = clearSymbol;
+	static WithSubscription: typeof SubscriptionMapWithSubscription;
+	static Item: typeof SubscriptionMapItem;
 	
 }
 
 
-SubscriptionMap.WithSubscription = class SubscriptionMapWithSubscription extends SubscriptionMap {
-	constructor(publicationName, params, onUpdate, immediately = true) {
+export class SubscriptionMapWithSubscription<I extends Item = Item> extends SubscriptionMap<I> {
+	constructor(publicationName: string, params: unknown[], onUpdate: UpdateHandler<I>, immediately = true) {
 		super(null, onUpdate);
 		
 		this.publicationName = publicationName;
@@ -303,12 +354,15 @@ SubscriptionMap.WithSubscription = class SubscriptionMapWithSubscription extends
 		
 	}
 	
-	subscription = null;
+	publicationName;
+	params;
+	
+	subscription: null | Subscription = null;
 	
 	subscribe() {
 		
 		if (!this.subscription)
-			this.subscription = new Subscription("map", this.publicationName, this.params, updates => this.update(updates));
+			this.subscription = new Subscription("map", this.publicationName, this.params, updates => this.update(updates as Updates<I>));
 		
 	}
 	
@@ -329,7 +383,7 @@ SubscriptionMap.WithSubscription = class SubscriptionMapWithSubscription extends
 		return this.unsubscribe;
 	}
 	
-	renew(publicationName, params) {
+	renew(publicationName?: string, params?: unknown[]) {
 		
 		if (this.subscription) {
 			this.unsubscribe();
@@ -366,28 +420,36 @@ SubscriptionMap.WithSubscription = class SubscriptionMapWithSubscription extends
 	static renewSymbol = renewSymbol;
 	static getSubscriptionSymbol = getSubscriptionSymbol;
 	
-};
+}
+
+SubscriptionMap.WithSubscription = SubscriptionMapWithSubscription;
 
 
-SubscriptionMap.Item = class SubscriptionMapItem {
-	constructor(map, updates) {
-		this.#map = map;
+export class SubscriptionMapItem {
+	constructor(map: SubscriptionMap, updates: GenericItem) {
+		this.map = map;
 		
 		this.update(updates);
 		
 	}
 	
-	#map;
+	_id!: string;
+	
+	private map;
 	
-	update(updates) {
+	update(updates: GenericItem) {
 		Object.assign(this, updates);
 		
 	}
 	
 	delete() {
 		
-		this.#map.delete(this._id);
+		this.map.delete(this._id);
 		
 	}
 	
-};
+}
+
+SubscriptionMap.Item = SubscriptionMapItem;
+
+export { Updated as SubscriptionMapUpdated };

package/src/SubscriptionObject.ts

@@ -0,0 +1,168 @@
+import { Subscription } from "./Subscription";
+import {
+	clearSymbol,
+	getAsInitialUpdatedSymbol,
+	getAsUpdatesSymbol,
+	getHandleUpdateSymbol,
+	getSubscriptionSymbol,
+	renewSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol,
+	updateSymbol
+} from "./symbols";
+
+
+const handleUpdateSymbol = Symbol("handleUpdate");
+const updatesSymbol = Symbol("updates");
+
+export type Updated = Record<string, unknown>;
+export type Updates = null | Record<string, unknown>;
+type UpdateHandler = (object: SubscriptionObject, updated: Updated, updates: Updates) => void;
+
+
+export class SubscriptionObject {
+	constructor(updates?: Updates, onUpdate?: UpdateHandler) {
+		if (onUpdate)
+			this[handleUpdateSymbol] = onUpdate;
+		
+		if (updates)
+			this[updateSymbol](updates);
+		
+	}
+	
+	[handleUpdateSymbol]?: UpdateHandler;
+	
+	[updatesSymbol]: Updates = null;
+	
+	[getHandleUpdateSymbol]() {
+		return this[handleUpdateSymbol];
+	}
+	
+	[setHandleUpdateSymbol](handleUpdate: UpdateHandler) {
+		return (this[handleUpdateSymbol] = handleUpdate);
+	}
+	
+	[updateSymbol](updates: Updates) {
+		if (updates) {
+			for (const key in this[updatesSymbol])// eslint-disable-line guard-for-in
+				delete this[key];
+			for (const key in updates)// eslint-disable-line guard-for-in
+				this[key] = updates[key];
+			this[updatesSymbol] = updates;
+		} else
+			this[clearSymbol]();
+		
+		this[handleUpdateSymbol]?.(this, this, this[updatesSymbol]);
+		
+		return this;
+	}
+	
+	[getAsUpdatesSymbol]() {
+		return this[updatesSymbol] && { ...this[updatesSymbol] };
+	}
+	
+	[getAsInitialUpdatedSymbol]() {
+		return this.valueOf();
+	}
+	
+	[clearSymbol]() {
+		
+		for (const key in this)// eslint-disable-line guard-for-in
+			delete this[key];
+		this[updatesSymbol] = null;
+		
+	}
+	
+	valueOf() {
+		return this[updatesSymbol] && this;
+	}
+	
+	get [Symbol.toStringTag]() {
+		return "SubscriptionObject";
+	}
+	
+	[key: string]: unknown;
+	
+	
+	static updateSymbol = updateSymbol;
+	static getHandleUpdateSymbol = getHandleUpdateSymbol;
+	static setHandleUpdateSymbol = setHandleUpdateSymbol;
+	static getAsUpdatesSymbol = getAsUpdatesSymbol;
+	static getAsInitialUpdatedSymbol = getAsInitialUpdatedSymbol;
+	static clearSymbol = clearSymbol;
+	static WithSubscription: typeof SubscriptionObjectWithSubscription;
+	
+}
+
+
+export class SubscriptionObjectWithSubscription extends SubscriptionObject {
+	constructor(publicationName: string, params: unknown[], onUpdate: UpdateHandler, immediately = true) {
+		super(null, onUpdate);
+		
+		this.publicationName = publicationName;
+		this.params = params;
+		
+		if (immediately)
+			this[subscribeSymbol]();
+		
+	}
+	
+	private publicationName;
+	private params;
+	private subscription: null | Subscription = null;
+	
+	[subscribeSymbol]() {
+		
+		if (!this.subscription)
+			this.subscription = new Subscription("object", this.publicationName, this.params, updates => this[updateSymbol](updates as Updates));
+		
+	}
+	
+	[unsubscribeSymbol]() {
+		
+		if (this.subscription) {
+			this.subscription.cancel();
+			this.subscription = null;
+		}
+		
+	}
+	
+	[renewSymbol](publicationName?: string, params?: unknown[]) {
+		
+		if (this.subscription) {
+			this[unsubscribeSymbol]();
+			
+			if (publicationName)
+				if (Array.isArray(publicationName))
+					params = publicationName;
+				else
+					this.publicationName = publicationName;
+			
+			if (params)
+				this.params = params;
+			
+			this[subscribeSymbol]();
+		}
+		
+	}
+	
+	[getSubscriptionSymbol]() {
+		return this.subscription;
+	}
+	
+	get [Symbol.toStringTag]() {
+		return "SubscriptionObjectWithSubscription";
+	}
+	
+	
+	static subscribeSymbol = subscribeSymbol;
+	static unsubscribeSymbol = unsubscribeSymbol;
+	static renewSymbol = renewSymbol;
+	static getSubscriptionSymbol = getSubscriptionSymbol;
+	
+}
+
+SubscriptionObject.WithSubscription = SubscriptionObjectWithSubscription;
+
+export { Updated as SubscriptionObjectUpdated };

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from "./Subscription.js";
+export { SubscriptionArray, SubscriptionArrayUpdated, SubscriptionArrayWithSubscription } from "./SubscriptionArray";
+export * from "./SubscriptionGroup";
+export { SubscriptionMap, SubscriptionMapUpdated, SubscriptionMapWithSubscription } from "./SubscriptionMap";
+export { SubscriptionObject, SubscriptionObjectUpdated, SubscriptionObjectWithSubscription } from "./SubscriptionObject";
+export {
+	clearSymbol,
+	getAsInitialUpdatedSymbol,
+	getAsUpdatesSymbol,
+	getHandleSubscriptionSymbol,
+	getHandleUpdateSymbol,
+	getSubscriptionSymbol,
+	renewSymbol,
+	setHandleSubscriptionSymbol,
+	setHandleUpdateSymbol,
+	subscribeSymbol,
+	unsubscribeSymbol,
+	updateSymbol
+} from "./symbols";