aberdeen 1.0.5 → 1.0.6

package/src/helpers/reverseSortedSet.ts

@@ -1,188 +1,197 @@
-type Item<T> = T & {[idx: symbol]: Item<T>}
+type Item<T> = T & { [idx: symbol]: Item<T> };
 
 /**
  * A set-like collection of objects that can do iteration sorted by a specified index property.
  * It also allows retrieving an object by its index property, and quickly getting the object
  * that comes immediately after a given object.
- * 
+ *
  * It's implemented as a skiplist, maintaining all meta-data as part of the objects that it
  * is tracking, for performance.
  */
 export class ReverseSortedSet<T extends object> {
-    // A fake item, that is not actually T, but *does* contain symbols pointing at the first item for each level.
-    private tail: Item<T>
-    // As every SkipList instance has its own symbols, an object can be included in more than one SkipList.
-    private symbols: symbol[]
-
-    /**
-     * Create an empty SortedSet.
-     * 
-     * @param keyProp The name of the property that should be used as the index of this collection. Comparison
-     * using `<` will be done on this property, so it should probably be a number or a string (or something that
-     * has a useful toString-conversion).
-     */
-    constructor(private keyProp: keyof T) {
-        this.tail = {} as Item<T>
-        this.symbols = [Symbol(0)]
-    }
-
-    /**
-     * Add an object to the `SortedSet`.
-     * 
-     * @param item The object to be added to the set. One or more properties with
-     *  `Symbol` keys will be added to it, for `SortedSet` internals.
-     * @returns `true` if the item was added, or `false` if it was *not* added
-     *  because the item already was part of this set.
-     * 
-     * Note that though an item object may only be part of a particular `SortedSet`
-     * once, index properties may be duplicate and an item object may be part of
-     * more than one `SortedSet`.
-     * 
-     * **IMPORTANT:** After adding an object, do not modify its index property,
-     * as this will lead to undefined (broken) behavior on the entire set.
-     * 
-     * Time complexity: O(log n)
-     */
-    add(item: T): boolean {
-        if (this.symbols[0] in item) return false // Already included
-
-        // Start at level 1. Keep upping the level by 1 with 1/8 chance.
-        const level = 1 + (Math.clz32(Math.random() * 0xFFFFFFFF) >> 2)
-        for(let l = this.symbols.length; l < level; l++) this.symbols.push(Symbol(l))
-
-        const keyProp = this.keyProp
-        const key = item[keyProp]
-    
-        let prev: Item<T> | undefined
-        let current: Item<T> = this.tail;
-        for (let l = this.symbols.length-1; l>=0; l--) {
-            const symbol = this.symbols[l]
-            while ((prev = current[symbol] as Item<T>) && prev[keyProp] > key) current = prev;
-            if (l < level) {
-                (item as any)[symbol] = current[symbol];
-                (current as any)[symbol] = item;
-            }
-        }
-
-        return true // Added
-    }
-
-    /**
-     * @param item An object to test for inclusion in the set.
-     * @returns true if this object item is already part of the set.
-     */
-    has(item: T): boolean {
-        return this.symbols[0] in item;
-    }
-
-    /**
-     * Remove and return the last item.
-     * @returns what was previously the last item in the sorted set, or `undefined` if the set was empty.
-     */
-    fetchLast(): T | undefined {
-        let item = this.tail[this.symbols[0]];
-        if (item) {
-            this.remove(item);
-            return item;
-        }
-    }
-
-    /**
-     * @returns whether the set is empty (`true`) or has at least one item (`false`).
-     */
-    isEmpty(): boolean {
-        return this.tail[this.symbols[0]] === undefined;
-    }
-
-    /**
-     * Retrieve an item object based on its index property value. 
-     * 
-     * @param indexValue The index property value to search for.
-     * @returns `undefined` if the index property value does not exist in the `SortedSet` or
-     *  otherwise the *first* item object that has this index value (meaning any further
-     *  instances can be iterated using `next()`).
-     * 
-     * Time complexity: O(log n)
-     */
-    get(indexValue: string|number): T | undefined {
-        const keyProp = this.keyProp
-        let current = this.tail;
-        let prev
-        for (let l = this.symbols.length-1; l>=0; l--) {
-            const symbol = this.symbols[l]
-            while ((prev = current[symbol] as Item<T>) && prev[keyProp] > indexValue) current = prev;
-        }
-        return current[this.symbols[0]]?.[keyProp] === indexValue ? current[this.symbols[0]] : undefined;
-    }
-
-    /**
-     * The iterator will go through the items in reverse index-order.
-     */
-    *[Symbol.iterator](): IterableIterator<T> {
-        let symbol = this.symbols[0]
-        let node: Item<T> | undefined = this.tail[symbol] as Item<T>;
-        while (node) {
-            yield node;
-            node = node[symbol] as Item<T> | undefined;
-        }
-    }
-
-    /**
-     * Given an item object, returns the one that comes right before in the set.
-     * @param item The object to start from.
-     * @returns The next object, or `undefined` if there is none.
-     * 
-     * Time complexity: O(1)
-     */
-    prev(item: T): T | undefined {
-        return (item as Item<T>)[this.symbols[0]]
-    }
-
-    /**
-     * Remove an item object from the set, deleting all meta-data keys that
-     * were created on `add()`.
-     * @param item The object to be removed.
-     * @returns `true` on success or `false` when the item was not part of the set.
-     *
-     * Time complexity: O(log n)
-     */
-    remove(item: T): boolean {
-        if (!(this.symbols[0] in item)) return false;
-        const keyProp = this.keyProp
-        const prop = item[keyProp];
-        
-        let prev: Item<T> | undefined
-        let current: Item<T> = this.tail;
-        
-        for (let l = this.symbols.length - 1; l >= 0; l--) {
-            const symbol = this.symbols[l];
-            while ((prev = current[symbol] as Item<T>) && prev[keyProp] >= prop && prev !== item) current = prev
-            if (prev === item) {
-                (current as any)[symbol] = prev[symbol]
-                delete prev[symbol]
-            }
-        }
-
-        return prev === item
-    }
-
-    /**
-     * Remove all items for the set.
-     *
-     * Time complexity: O(n)
-     */    
-    clear(): void {
-        const symbol = this.symbols[0];
-        let current: Item<T> | undefined = this.tail;
-        while (current) {
-            const prev = current[symbol] as Item<T> | undefined
-            for (const symbol of this.symbols) {
-                if (!(symbol in current)) break
-                delete current[symbol];
-            }
-            current = prev
-        }
-        this.tail = {} as Item<T>;
-    }
+	// A fake item, that is not actually T, but *does* contain symbols pointing at the first item for each level.
+	private tail: Item<T>;
+	// As every SkipList instance has its own symbols, an object can be included in more than one SkipList.
+	private symbols: symbol[];
+
+	/**
+	 * Create an empty SortedSet.
+	 *
+	 * @param keyProp The name of the property that should be used as the index of this collection. Comparison
+	 * using `<` will be done on this property, so it should probably be a number or a string (or something that
+	 * has a useful toString-conversion).
+	 */
+	constructor(private keyProp: keyof T) {
+		this.tail = {} as Item<T>;
+		this.symbols = [Symbol(0)];
+	}
+
+	/**
+	 * Add an object to the `SortedSet`.
+	 *
+	 * @param item The object to be added to the set. One or more properties with
+	 *  `Symbol` keys will be added to it, for `SortedSet` internals.
+	 * @returns `true` if the item was added, or `false` if it was *not* added
+	 *  because the item already was part of this set.
+	 *
+	 * Note that though an item object may only be part of a particular `SortedSet`
+	 * once, index properties may be duplicate and an item object may be part of
+	 * more than one `SortedSet`.
+	 *
+	 * **IMPORTANT:** After adding an object, do not modify its index property,
+	 * as this will lead to undefined (broken) behavior on the entire set.
+	 *
+	 * Time complexity: O(log n)
+	 */
+	add(item: T): boolean {
+		if (this.symbols[0] in item) return false; // Already included
+
+		// Start at level 1. Keep upping the level by 1 with 1/8 chance.
+		const level = 1 + (Math.clz32(Math.random() * 0xffffffff) >> 2);
+		for (let l = this.symbols.length; l < level; l++)
+			this.symbols.push(Symbol(l));
+
+		const keyProp = this.keyProp;
+		const key = item[keyProp];
+
+		let prev: Item<T> | undefined;
+		let current: Item<T> = this.tail;
+		for (let l = this.symbols.length - 1; l >= 0; l--) {
+			const symbol = this.symbols[l];
+			while ((prev = current[symbol] as Item<T>) && prev[keyProp] > key)
+				current = prev;
+			if (l < level) {
+				(item as any)[symbol] = current[symbol];
+				(current as any)[symbol] = item;
+			}
+		}
+
+		return true; // Added
+	}
+
+	/**
+	 * @param item An object to test for inclusion in the set.
+	 * @returns true if this object item is already part of the set.
+	 */
+	has(item: T): boolean {
+		return this.symbols[0] in item;
+	}
+
+	/**
+	 * Remove and return the last item.
+	 * @returns what was previously the last item in the sorted set, or `undefined` if the set was empty.
+	 */
+	fetchLast(): T | undefined {
+		const item = this.tail[this.symbols[0]];
+		if (item) {
+			this.remove(item);
+			return item;
+		}
+	}
+
+	/**
+	 * @returns whether the set is empty (`true`) or has at least one item (`false`).
+	 */
+	isEmpty(): boolean {
+		return this.tail[this.symbols[0]] === undefined;
+	}
+
+	/**
+	 * Retrieve an item object based on its index property value.
+	 *
+	 * @param indexValue The index property value to search for.
+	 * @returns `undefined` if the index property value does not exist in the `SortedSet` or
+	 *  otherwise the *first* item object that has this index value (meaning any further
+	 *  instances can be iterated using `next()`).
+	 *
+	 * Time complexity: O(log n)
+	 */
+	get(indexValue: string | number): T | undefined {
+		const keyProp = this.keyProp;
+		let current = this.tail;
+		let prev: Item<T> | undefined;
+		for (let l = this.symbols.length - 1; l >= 0; l--) {
+			const symbol = this.symbols[l];
+			while ((prev = current[symbol] as Item<T>) && prev[keyProp] > indexValue)
+				current = prev;
+		}
+		return current[this.symbols[0]]?.[keyProp] === indexValue
+			? current[this.symbols[0]]
+			: undefined;
+	}
+
+	/**
+	 * The iterator will go through the items in reverse index-order.
+	 */
+	*[Symbol.iterator](): IterableIterator<T> {
+		const symbol = this.symbols[0];
+		let node: Item<T> | undefined = this.tail[symbol] as Item<T>;
+		while (node) {
+			yield node;
+			node = node[symbol] as Item<T> | undefined;
+		}
+	}
+
+	/**
+	 * Given an item object, returns the one that comes right before in the set.
+	 * @param item The object to start from.
+	 * @returns The next object, or `undefined` if there is none.
+	 *
+	 * Time complexity: O(1)
+	 */
+	prev(item: T): T | undefined {
+		return (item as Item<T>)[this.symbols[0]];
+	}
+
+	/**
+	 * Remove an item object from the set, deleting all meta-data keys that
+	 * were created on `add()`.
+	 * @param item The object to be removed.
+	 * @returns `true` on success or `false` when the item was not part of the set.
+	 *
+	 * Time complexity: O(log n)
+	 */
+	remove(item: T): boolean {
+		if (!(this.symbols[0] in item)) return false;
+		const keyProp = this.keyProp;
+		const prop = item[keyProp];
+
+		let prev: Item<T> | undefined;
+		let current: Item<T> = this.tail;
+
+		for (let l = this.symbols.length - 1; l >= 0; l--) {
+			const symbol = this.symbols[l];
+			while (
+				(prev = current[symbol] as Item<T>) &&
+				prev[keyProp] >= prop &&
+				prev !== item
+			)
+				current = prev;
+			if (prev === item) {
+				(current as any)[symbol] = prev[symbol];
+				delete prev[symbol];
+			}
+		}
+
+		return prev === item;
+	}
+
+	/**
+	 * Remove all items for the set.
+	 *
+	 * Time complexity: O(n)
+	 */
+	clear(): void {
+		const symbol = this.symbols[0];
+		let current: Item<T> | undefined = this.tail;
+		while (current) {
+			const prev = current[symbol] as Item<T> | undefined;
+			for (const symbol of this.symbols) {
+				if (!(symbol in current)) break;
+				delete current[symbol];
+			}
+			current = prev;
+		}
+		this.tail = {} as Item<T>;
+	}
 }
-

package/src/prediction.ts

@@ -1,70 +1,85 @@
-import {withEmitHandler, defaultEmitHandler} from './aberdeen.js'
-import type { DatumType, TargetType } from './aberdeen.js';
+import { defaultEmitHandler, withEmitHandler } from "./aberdeen.js";
+import type { DatumType, TargetType } from "./aberdeen.js";
 
-/** 
+/**
  * Represents a set of changes that can be applied to proxied objects.
  * This is an opaque type - its internal structure is not part of the public API.
  * @private
  */
 export type Patch = Map<TargetType, Map<any, [DatumType, DatumType]>>;
 
-
 function recordPatch(func: () => void): Patch {
-	const recordingPatch = new Map()
-	withEmitHandler(function(target, index, newData, oldData) {
-		addToPatch(recordingPatch, target, index, newData, oldData)
-	}, func)
-	return recordingPatch
+	const recordingPatch = new Map();
+	withEmitHandler((target, index, newData, oldData) => {
+		addToPatch(recordingPatch, target, index, newData, oldData);
+	}, func);
+	return recordingPatch;
 }
 
-function addToPatch(patch: Patch, collection: TargetType, index: any, newData: DatumType, oldData: DatumType) {
-	let collectionMap = patch.get(collection)
+function addToPatch(
+	patch: Patch,
+	collection: TargetType,
+	index: any,
+	newData: DatumType,
+	oldData: DatumType,
+) {
+	let collectionMap = patch.get(collection);
 	if (!collectionMap) {
-		collectionMap = new Map()
-		patch.set(collection, collectionMap)
+		collectionMap = new Map();
+		patch.set(collection, collectionMap);
 	}
-	let prev = collectionMap.get(index)
-	if (prev) oldData = prev[1]
-	if (newData === oldData) collectionMap.delete(index)
-	else collectionMap.set(index, [newData, oldData])
+	const prev = collectionMap.get(index);
+	const oldData0 = prev ? prev[1] : oldData;
+	if (newData === oldData0) collectionMap.delete(index);
+	else collectionMap.set(index, [newData, oldData0]);
 }
 
 function emitPatch(patch: Patch) {
-	for(let [collection, collectionMap] of patch) {
-		for(let [index, [newData, oldData]] of collectionMap) {
+	for (const [collection, collectionMap] of patch) {
+		for (const [index, [newData, oldData]] of collectionMap) {
 			defaultEmitHandler(collection, index, newData, oldData);
 		}
 	}
 }
 
-function mergePatch(target: Patch, source: Patch, reverse: boolean = false) {
-	for(let [collection, collectionMap] of source) {
-		for(let [index, [newData, oldData]] of collectionMap) {
-			addToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData)
+function mergePatch(target: Patch, source: Patch, reverse = false) {
+	for (const [collection, collectionMap] of source) {
+		for (const [index, [newData, oldData]] of collectionMap) {
+			addToPatch(
+				target,
+				collection,
+				index,
+				reverse ? oldData : newData,
+				reverse ? newData : oldData,
+			);
 		}
 	}
 }
 
-function silentlyApplyPatch(patch: Patch, force: boolean = false): boolean {
-	for(let [collection, collectionMap] of patch) {
-		for(let [index, [newData, oldData]] of collectionMap) {
-			let actualData = (collection as any)[index]
+function silentlyApplyPatch(patch: Patch, force = false): boolean {
+	for (const [collection, collectionMap] of patch) {
+		for (const [index, [newData, oldData]] of collectionMap) {
+			const actualData = (collection as any)[index];
 			if (actualData !== oldData) {
-				if (force) setTimeout(() => { throw new Error(`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`)}, 0)
-				else return false
+				if (force)
+					setTimeout(() => {
+						throw new Error(
+							`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`,
+						);
+					}, 0);
+				else return false;
 			}
 		}
 	}
-	for(let [collection, collectionMap] of patch) {
-		for(let [index, [newData, oldData]] of collectionMap) {
-			(collection as any)[index] = newData
+	for (const [collection, collectionMap] of patch) {
+		for (const [index, [newData, oldData]] of collectionMap) {
+			(collection as any)[index] = newData;
 		}
 	}
-	return true
+	return true;
 }
 
-
-const appliedPredictions: Array<Patch> = []
+const appliedPredictions: Array<Patch> = [];
 
 /**
  * Run the provided function, while treating all changes to Observables as predictions,
@@ -76,19 +91,19 @@ const appliedPredictions: Array<Patch> = []
  * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.
  */
 export function applyPrediction(predictFunc: () => void): Patch {
-	let patch = recordPatch(predictFunc)
-	appliedPredictions.push(patch)
-	emitPatch(patch)
-	return patch
+	const patch = recordPatch(predictFunc);
+	appliedPredictions.push(patch);
+	emitPatch(patch);
+	return patch;
 }
 
 /**
  * Temporarily revert all outstanding predictions, optionally run the provided function
  * (which will generally make authoritative changes to the data based on a server response),
- * and then attempt to reapply the predictions on top of the new canonical state, dropping 
+ * and then attempt to reapply the predictions on top of the new canonical state, dropping
  * any predictions that can no longer be applied cleanly (the data has been modified) or
  * that were specified in `dropPredictions`.
- * 
+ *
  * All of this is done such that redraws are only triggered if the overall effect is an
  * actual change to an `Observable`.
  * @param canonFunc The function to run without any predictions applied. This will typically
@@ -97,26 +112,29 @@ export function applyPrediction(predictFunc: () => void): Patch {
  *  to undo. Typically, when a server response for a certain request is being handled,
  *  you'd want to drop the prediction that was done for that request.
  */
-export function applyCanon(canonFunc?: (() => void), dropPredictions: Array<Patch> = []) {
-	
-	let resultPatch = new Map()
-	for(let prediction of appliedPredictions) mergePatch(resultPatch, prediction, true)
-	silentlyApplyPatch(resultPatch, true)
+export function applyCanon(
+	canonFunc?: () => void,
+	dropPredictions: Array<Patch> = [],
+) {
+	const resultPatch = new Map();
+	for (const prediction of appliedPredictions)
+		mergePatch(resultPatch, prediction, true);
+	silentlyApplyPatch(resultPatch, true);
 
-	for(let prediction of dropPredictions) {
-		let pos = appliedPredictions.indexOf(prediction)
-		if (pos >= 0) appliedPredictions.splice(pos, 1)
+	for (const prediction of dropPredictions) {
+		const pos = appliedPredictions.indexOf(prediction);
+		if (pos >= 0) appliedPredictions.splice(pos, 1);
 	}
-	if (canonFunc) mergePatch(resultPatch, recordPatch(canonFunc))
+	if (canonFunc) mergePatch(resultPatch, recordPatch(canonFunc));
 
-	for(let idx=0; idx<appliedPredictions.length; idx++) {
+	for (let idx = 0; idx < appliedPredictions.length; idx++) {
 		if (silentlyApplyPatch(appliedPredictions[idx])) {
-			mergePatch(resultPatch, appliedPredictions[idx])
+			mergePatch(resultPatch, appliedPredictions[idx]);
 		} else {
-			appliedPredictions.splice(idx, 1)
-			idx--
+			appliedPredictions.splice(idx, 1);
+			idx--;
 		}
 	}
 
-	emitPatch(resultPatch)
+	emitPatch(resultPatch);
 }