@mark1russell7/collections 0.8.0 → 0.9.0

package/build/index.js

@@ -456,6 +456,38 @@ const onWhen = (emitter, event, predicate, listener) => {
 		if (predicate(payload)) listener(payload);
 	});
 };
+// src/core/removals.ts
+/** The key of the removal channel on a layer. */
+const removals = Symbol.for("@mark1russell7/collections/removals");
+/**
+* This function gives the removal channel of a collection, or `undefined` when no layer of it removes.
+*/
+function removalsOf(collection) {
+	const channel = collection[removals];
+	if (typeof channel !== "object" || channel === null) return void 0;
+	return typeof channel.on === "function" ? channel : void 0;
+}
+/**
+* This function makes the channel of a removing layer over `next`.
+* The channel forwards each removal below. It calls `below` first, so the layer corrects its own state first.
+*/
+function removalSource(next, below) {
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (removal) => {
+		for (const listener of [...listeners]) listener(removal);
+	};
+	removalsOf(next)?.on((removal) => {
+		below?.(removal);
+		emit(removal);
+	});
+	return {
+		channel: { on(listener) {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		} },
+		emit
+	};
+}
 // src/storage/listeners.ts
 /**
 * The default handler of the error of a listener. It throws the error again in a microtask, as an
@@ -4509,6 +4541,7 @@ function boundedList(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedList");
 	return (next) => {
+		const source = removalSource(next);
 		const handleOverflow = (element, dropFrom = "first") => {
 			if (onOverflow) {
 				const context = {
@@ -4523,8 +4556,12 @@ function boundedList(options) {
 				case "throw": throw new Error(`List is full (capacity: ${capacity})`);
 				case "drop-oldest":
 					if (!next.isEmpty) {
-						if (dropFrom === "last") next.pop();
-						else next.shift();
+						const value = dropFrom === "last" ? next.pop() : next.shift();
+						source.emit({
+							value,
+							end: dropFrom,
+							reason: "drop"
+						});
 					}
 					break;
 				case "drop-newest": return;
@@ -4536,6 +4573,7 @@ function boundedList(options) {
 		};
 		const shifted = (index) => policy === "drop-oldest" ? Math.max(0, index - 1) : index;
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4619,6 +4657,7 @@ function boundedQueue(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedQueue");
 	return (next) => {
+		const source = removalSource(next);
 		const handleOverflow = (element) => {
 			if (onOverflow) {
 				const context = {
@@ -4632,7 +4671,11 @@ function boundedQueue(options) {
 			switch (policy) {
 				case "throw": throw new Error(`Queue is full (capacity: ${capacity})`);
 				case "drop-oldest":
-					if (!next.isEmpty) next.poll();
+					if (!next.isEmpty) source.emit({
+						value: next.poll(),
+						end: "first",
+						reason: "drop"
+					});
 					break;
 				case "drop-newest":
 				case "reject": return;
@@ -4642,6 +4685,7 @@ function boundedQueue(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4671,6 +4715,7 @@ function boundedDeque(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedDeque");
 	return (next) => {
+		const source = removalSource(next);
 		const handleOverflow = (element, dropFrom) => {
 			if (onOverflow) {
 				const context = {
@@ -4685,8 +4730,12 @@ function boundedDeque(options) {
 				case "throw": throw new Error(`Deque is full (capacity: ${capacity})`);
 				case "drop-oldest":
 					if (!next.isEmpty) {
-						if (dropFrom === "last") next.removeLast();
-						else next.removeFirst();
+						const value = dropFrom === "last" ? next.removeLast() : next.removeFirst();
+						source.emit({
+							value,
+							end: dropFrom,
+							reason: "drop"
+						});
 					}
 					break;
 				case "drop-newest":
@@ -4697,6 +4746,7 @@ function boundedDeque(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4731,6 +4781,9 @@ function boundedMap(options) {
 	const capacity = checkCapacity(options.capacity, "boundedMap");
 	return (next) => {
 		let insertionOrder = [];
+		const source = removalSource(next, ({ key }) => {
+			insertionOrder = insertionOrder.filter((k) => !next.keyEq(k, key));
+		});
 		const handleOverflow = (key, value) => {
 			if (onOverflow) onOverflow({
 				key,
@@ -4742,9 +4795,17 @@ function boundedMap(options) {
 			switch (policy) {
 				case "throw": throw new Error(`Map is full (capacity: ${capacity})`);
 				case "drop-oldest":
-					if (insertionOrder.length > 0) {
+					while (insertionOrder.length > 0) {
 						const oldestKey = insertionOrder.shift();
+						if (!next.has(oldestKey)) continue;
+						const value = next.get(oldestKey);
 						next.delete(oldestKey);
+						source.emit({
+							key: oldestKey,
+							value,
+							reason: "drop"
+						});
+						break;
 					}
 					break;
 				case "drop-newest":
@@ -4755,6 +4816,7 @@ function boundedMap(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -5084,6 +5146,24 @@ function safe() {
 }
 // src/behaviors/evented.ts
 /**
+* This function gives each removal below `next` to `listener` and counts the removals.
+* With the counts, a layer tells a refused add (the size did not grow) from an add that caused a drop.
+*/
+function hear(next, listener) {
+	const heard = {
+		all: 0,
+		first: 0
+	};
+	removalsOf(next)?.on((removal) => {
+		heard.all++;
+		if ("end" in removal && removal.end === "first") heard.first++;
+		listener(removal);
+	});
+	return heard;
+}
+/** This function tells if a call added an element: the size grew, after the removals of the layers below. */
+const added = (size, sizeBefore, heard, heardBefore) => size - sizeBefore + heard.all - heardBefore > 0;
+/**
 * This function makes an evented List middleware.
 *
 * This function emits events for add, remove, set, clear, sort, and reverse operations.
@@ -5091,28 +5171,44 @@ function safe() {
 function eventedList() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ value, end, reason }) => emitter.emit("remove", end === void 0 ? {
+			value,
+			reason
+		} : {
+			value,
+			index: end === "first" ? 0 : next.size,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "add":
 				case "push": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					const result = value.call(target, element);
-					emitter.emit("add", { value: element });
+					if (added(target.size, size, heard, all)) emitter.emit("add", { value: element });
 					return result;
 				};
 				case "unshift": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					value.call(target, element);
-					emitter.emit("add", {
+					if (added(target.size, size, heard, all)) emitter.emit("add", {
 						value: element,
 						index: 0
 					});
 				};
 				case "insert": return function(index, element) {
+					const size = target.size;
+					const all = heard.all;
+					const first = heard.first;
 					value.call(target, index, element);
+					if (!added(target.size, size, heard, all)) return;
 					emitter.emit("add", {
 						value: element,
-						index
+						index: heard.first > first ? Math.max(0, index - 1) : index
 					});
 				};
 				case "set": return function(index, element) {
@@ -5139,7 +5235,10 @@ function eventedList() {
 				};
 				case "pop": return function() {
 					const removed = value.call(target);
-					emitter.emit("remove", { value: removed });
+					emitter.emit("remove", {
+						value: removed,
+						index: target.size
+					});
 					return removed;
 				};
 				case "shift": return function() {
@@ -5173,6 +5272,10 @@ function eventedList() {
 function eventedQueue() {
 	return (next) => {
 		const emitter = new Emitter();
+		hear(next, ({ value, reason }) => emitter.emit("dequeue", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
@@ -5205,23 +5308,25 @@ function eventedQueue() {
 function eventedDeque() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ value, end, reason }) => emitter.emit(end === "last" ? "removeLast" : "removeFirst", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "addFirst":
 				case "offerFirst":
-				case "push": return function(element) {
-					const result = value.call(target, element);
-					emitter.emit("addFirst", { value: element });
-					return result;
-				};
 				case "addLast":
 				case "offerLast":
 				case "offer":
-				case "add": return function(element) {
+				case "add":
+				case "push": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					const result = value.call(target, element);
-					emitter.emit("addLast", { value: element });
+					if (added(target.size, size, heard, all)) emitter.emit(prop === "addFirst" || prop === "offerFirst" ? "addFirst" : "addLast", { value: element });
 					return result;
 				};
 				case "removeFirst":
@@ -5254,13 +5359,20 @@ function eventedDeque() {
 function eventedMap() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ key, value, reason }) => emitter.emit("delete", {
+			key,
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "set": return function(key, val) {
+					const size = target.size;
+					const all = heard.all;
 					const oldValue = value.call(target, key, val);
-					emitter.emit("set", {
+					if (oldValue !== void 0 || added(target.size, size, heard, all)) emitter.emit("set", {
 						key,
 						value: val,
 						oldValue
@@ -5290,6 +5402,10 @@ function eventedMap() {
 function evented() {
 	return (next) => {
 		const emitter = new Emitter();
+		hear(next, ({ value, reason }) => emitter.emit("remove", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
@@ -5662,6 +5778,10 @@ function lruMap(options) {
 			else tail = node.prev;
 			nodeMap.delete(node.key);
 		};
+		const source = removalSource(next, ({ key }) => {
+			const node = nodeMap.get(key);
+			if (node) removeNode(node);
+		});
 		const dropStaleNodes = () => {
 			for (const node of [...nodeMap.values()]) if (!next.has(node.key)) removeNode(node);
 		};
@@ -5676,24 +5796,23 @@ function lruMap(options) {
 					value: candidate.value,
 					timestamp: candidate.lastAccessed
 				});
+				source.emit({
+					key: candidate.key,
+					value: candidate.value,
+					reason: "evict"
+				});
 				return;
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "isFull") return target.size >= capacity;
 			const composite = compositeMapMethod(receiver, prop);
 			if (composite) return composite;
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "get": return function(key) {
-					let result;
-					try {
-						result = value.call(target, key);
-					} catch (error) {
-						const stale = nodeMap.get(key);
-						if (stale) removeNode(stale);
-						throw error;
-					}
+					const result = value.call(target, key);
 					const node = nodeMap.get(key);
 					if (node) moveToHead(node);
 					return result;
@@ -5701,10 +5820,7 @@ function lruMap(options) {
 				case "has": return function(key) {
 					const result = value.call(target, key);
 					const node = nodeMap.get(key);
-					if (node) {
-						if (result) moveToHead(node);
-						else removeNode(node);
-					}
+					if (node && result) moveToHead(node);
 					return result;
 				};
 				case "set": return function(key, val) {
@@ -5920,6 +6036,7 @@ function ttlMap(options) {
 	return (next) => {
 		const metadata = /* @__PURE__ */ new Map();
 		let intervalId = null;
+		const source = removalSource(next, ({ key }) => void metadata.delete(key));
 		const sweep = () => {
 			const now = Date.now();
 			for (const [key, entry] of metadata) {
@@ -5932,6 +6049,11 @@ function ttlMap(options) {
 					createdAt: entry.createdAt,
 					expiredAt: now
 				});
+				source.emit({
+					key,
+					value: entry.value,
+					reason: "expire"
+				});
 			}
 		};
 		intervalId = startExpirationTimer(sweep, checkInterval);
@@ -5943,6 +6065,7 @@ function ttlMap(options) {
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "dispose") return dispose;
+			if (prop === removals) return source.channel;
 			const composite = compositeMapMethod(receiver, prop);
 			if (composite) return composite;
 			sweep();
@@ -6006,6 +6129,7 @@ function ttlCollection(options) {
 	return (next) => {
 		const metadata = /* @__PURE__ */ new Map();
 		let intervalId = null;
+		const source = removalSource(next, ({ value }) => void metadata.delete(value));
 		const checkExpired = () => {
 			const now = Date.now();
 			const expired = [];
@@ -6020,6 +6144,10 @@ function ttlCollection(options) {
 						createdAt: entry.createdAt,
 						expiredAt: now
 					});
+					source.emit({
+						value: element,
+						reason: "expire"
+					});
 				}
 			}
 		};
@@ -6032,6 +6160,7 @@ function ttlCollection(options) {
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "dispose") return dispose;
+			if (prop === removals) return source.channel;
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "add": return function(element) {
@@ -7956,6 +8085,6 @@ function stringHashCode(str) {
 	}
 	return hash;
 }
-export { ArrayDeque, ArrayList, AsyncEmitter, AsyncQueue, Channel, CollectionBuilder, DEFAULT_CONFLICT_POLICY, DEFAULT_EVICTION_POLICY, DEFAULT_GROWTH_POLICY, DEFAULT_OVERFLOW_POLICY, DEFAULT_RETRY_POLICY, DEFAULT_UNDERFLOW_POLICY, DEFAULT_VALIDATION_POLICY, Emitter, EventBatcher, HashMap, HashSet, KEY_DIGITS, LRUCache, LinkedHashMap, LinkedList, PriorityQueue, StorageListeners, SummaryTree, TTLCache, TreeMap, TreeSet, arrayContains, arrayDeque, arrayIterator, arrayList, arrayRemove, arrayRemoveAll, asSettled, asyncQueue, average, averagingNumber, blockMethods, booleanCompare, bounded, boundedDeque, boundedList, boundedMap, boundedQueue, buffered, buildList, buildMap, bundle, channel, checkBounds, checkInsertBounds, checkRangeBounds, chunk, clamp, collect, toArray as collectToArray, toList as collectToList, toMap as collectToMap, toSet as collectToSet, combineHashes, compareKeys, comparing, comparingKey, compose, concat, count, counting, createEmitter, dateCompare, deepEq, defaultCompare, defaultEq, defaultHash, delegate, distinct, distinctConsecutive, dropIndex, emptyList, emptyMap, emptyQueue, enhanceMethod, enumerate, eqBy, evented, eventedDeque, eventedList, eventedMap, eventedQueue, every, fanIn, fanOut, filter, filtering, find, findIndex, findLastIndex, first, flatMap, flatMapping, flatten, forwardEvent, groupBy, groupingBy, groupingByWith, hasCapability, hashBy, hashMap, hashNumber, hashSet, hashString, immutableListOf, immutableMapOf, interceptMethods, isValidKey, toMap$1 as iterToMap, joining, keyBetween, keysBetween, keysForDrop, last, linkedHashMap, linkedList, listOf, lruCache, lruMap, map, mapOf, mapping, max, maxBy, merge, min, minBy, mutableListOf, mutableMapOf, nCopies, none, nullsFirst, nullsLast, numberCompare, onWhen, partition, partitioningBy, pipe, pipeline, priorityQueue, queueOf, range, rangeTo, readWriteLock, readonly, readonlyCollection, readonlyList, readonlyMap, readonlyQueue, reduce, reducing, reducingWith, reentrantSynchronized, reportListenerError, requireNonEmpty, requireNonNull, reverse, reverseArrayIterator, reversed, safe, safeDeque, safeList, safeMap, safeQueue, scan, select, shallowEq, singletonList, singletonMap, skip, skipWhile, some, sort, stringCompare, stringCompareIgnoreCase, stringHashCode, sum, summarizingNumber, summaryTree, summingNumber, synchronized, synchronizedCollection, synchronizedList, synchronizedMap, synchronizedSet, take, takeWhile, tap, teeing, thenComparing, ticker, timeout, toArray$1 as toArray, toList$1 as toList, toMap$2 as toMap, toSet$1 as toSet, treeMap, treeSet, ttlCache, ttlCollection, ttlMap, unbuffered, unmodifiableCollection, unmodifiableList, unmodifiableMap, window, workerPool, zip };
+export { ArrayDeque, ArrayList, AsyncEmitter, AsyncQueue, Channel, CollectionBuilder, DEFAULT_CONFLICT_POLICY, DEFAULT_EVICTION_POLICY, DEFAULT_GROWTH_POLICY, DEFAULT_OVERFLOW_POLICY, DEFAULT_RETRY_POLICY, DEFAULT_UNDERFLOW_POLICY, DEFAULT_VALIDATION_POLICY, Emitter, EventBatcher, HashMap, HashSet, KEY_DIGITS, LRUCache, LinkedHashMap, LinkedList, PriorityQueue, StorageListeners, SummaryTree, TTLCache, TreeMap, TreeSet, arrayContains, arrayDeque, arrayIterator, arrayList, arrayRemove, arrayRemoveAll, asSettled, asyncQueue, average, averagingNumber, blockMethods, booleanCompare, bounded, boundedDeque, boundedList, boundedMap, boundedQueue, buffered, buildList, buildMap, bundle, channel, checkBounds, checkInsertBounds, checkRangeBounds, chunk, clamp, collect, toArray as collectToArray, toList as collectToList, toMap as collectToMap, toSet as collectToSet, combineHashes, compareKeys, comparing, comparingKey, compose, concat, count, counting, createEmitter, dateCompare, deepEq, defaultCompare, defaultEq, defaultHash, delegate, distinct, distinctConsecutive, dropIndex, emptyList, emptyMap, emptyQueue, enhanceMethod, enumerate, eqBy, evented, eventedDeque, eventedList, eventedMap, eventedQueue, every, fanIn, fanOut, filter, filtering, find, findIndex, findLastIndex, first, flatMap, flatMapping, flatten, forwardEvent, groupBy, groupingBy, groupingByWith, hasCapability, hashBy, hashMap, hashNumber, hashSet, hashString, immutableListOf, immutableMapOf, interceptMethods, isValidKey, toMap$1 as iterToMap, joining, keyBetween, keysBetween, keysForDrop, last, linkedHashMap, linkedList, listOf, lruCache, lruMap, map, mapOf, mapping, max, maxBy, merge, min, minBy, mutableListOf, mutableMapOf, nCopies, none, nullsFirst, nullsLast, numberCompare, onWhen, partition, partitioningBy, pipe, pipeline, priorityQueue, queueOf, range, rangeTo, readWriteLock, readonly, readonlyCollection, readonlyList, readonlyMap, readonlyQueue, reduce, reducing, reducingWith, reentrantSynchronized, removalSource, removals, removalsOf, reportListenerError, requireNonEmpty, requireNonNull, reverse, reverseArrayIterator, reversed, safe, safeDeque, safeList, safeMap, safeQueue, scan, select, shallowEq, singletonList, singletonMap, skip, skipWhile, some, sort, stringCompare, stringCompareIgnoreCase, stringHashCode, sum, summarizingNumber, summaryTree, summingNumber, synchronized, synchronizedCollection, synchronizedList, synchronizedMap, synchronizedSet, take, takeWhile, tap, teeing, thenComparing, ticker, timeout, toArray$1 as toArray, toList$1 as toList, toMap$2 as toMap, toSet$1 as toSet, treeMap, treeSet, ttlCache, ttlCollection, ttlMap, unbuffered, unmodifiableCollection, unmodifiableList, unmodifiableMap, window, workerPool, zip };
 
 //# sourceMappingURL=index.js.map