@genome-spy/app 1.0.0 → 1.1.1

package/dist/SharedReadCache-Ey5QIiPM.js

@@ -0,0 +1,207 @@
+//#region ../../node_modules/@gmod/shared-read-cache/esm/throwIfAborted.js
+function e(e) {
+	if (e?.aborted) throw t(e);
+}
+function t(e) {
+	let t = e.reason;
+	return t === void 0 ? new DOMException("This operation was aborted", "AbortError") : t;
+}
+//#endregion
+//#region ../../node_modules/@gmod/shared-read-cache/esm/SharedReadCache.js
+function n(e) {
+	typeof e == "object" && e && "unref" in e && typeof e.unref == "function" && e.unref();
+}
+var r = class {
+	entries = /* @__PURE__ */ new Map();
+	total = 0;
+	settledCount = 0;
+	limit;
+	budget;
+	membership;
+	fill;
+	sizeOf;
+	toCacheKey;
+	evictionPolicy;
+	pending = 0;
+	batch = 0;
+	idleTimeoutMs;
+	sweepTimer;
+	constructor({ fill: e, maxSize: t = Infinity, sizeOf: n = () => 1, cacheKey: r = (e) => String(e), evictionPolicy: i = "lru", idleTimeoutMs: a = 0, budget: o } = {}) {
+		this.fill = e, this.evictionPolicy = i, this.limit = t, this.budget = o, this.membership = o?.register(this), this.sizeOf = n, this.toCacheKey = r, this.idleTimeoutMs = a > 0 ? a : void 0;
+	}
+	get size() {
+		return this.entries.size;
+	}
+	get totalSize() {
+		return this.total;
+	}
+	get maxSize() {
+		return this.limit;
+	}
+	set maxSize(e) {
+		this.limit = e, this.evict();
+	}
+	waiterCount(e) {
+		return this.entries.get(this.toCacheKey(e))?.signals.size ?? 0;
+	}
+	async get(t, n, r) {
+		e(n);
+		let i = this.toCacheKey(t), a = this.entries.get(i);
+		a && (this.isDoomed(a) ? (this.deleteKey(i), a = void 0) : this.touch(i, a)), a ??= this.start(i, t, r), a.settled || this.join(a, n);
+		try {
+			let t = await this.settleFor(a, n);
+			return e(n), t;
+		} catch (t) {
+			throw e(n), t;
+		}
+	}
+	settleFor(e, n) {
+		if (e.settled || n === void 0 || typeof n.addEventListener != "function") return e.promise;
+		let r = new AbortController();
+		return Promise.race([e.promise, new Promise((e, i) => {
+			n.addEventListener("abort", () => {
+				i(t(n));
+			}, {
+				once: !0,
+				signal: r.signal
+			});
+		})]).finally(() => {
+			r.abort();
+		});
+	}
+	getIfCached(e) {
+		let t = this.toCacheKey(e), n = this.entries.get(t);
+		if (n) {
+			if (this.isDoomed(n)) {
+				this.deleteKey(t);
+				return;
+			}
+			return this.touch(t, n), n.promise;
+		}
+	}
+	has(e) {
+		let t = this.entries.get(this.toCacheKey(e));
+		return t !== void 0 && !this.isDoomed(t);
+	}
+	delete(e) {
+		this.deleteKey(this.toCacheKey(e));
+	}
+	clear() {
+		for (let e of this.entries.values()) this.detach(e);
+		this.entries.clear(), this.charge(-this.total), this.total = 0, this.settledCount = 0, this.stopSweep();
+	}
+	touch(e, t) {
+		this.entries.delete(e), this.entries.set(e, t), t.batch = this.batch, t.lastTouched = Date.now(), t.seq = this.stamp();
+	}
+	stamp() {
+		return this.budget ? this.budget.nextSeq() : 0;
+	}
+	isDoomed(e) {
+		return !e.settled && e.controller.signal.aborted;
+	}
+	sweepIdle() {
+		let e = this.idleTimeoutMs;
+		if (e === void 0) return;
+		let t = Date.now() - e, n = 0;
+		for (let [e, r] of this.entries) r.settled && (r.lastTouched <= t ? this.deleteKey(e) : n++);
+		n === 0 && this.stopSweep();
+	}
+	startSweep() {
+		let e = this.idleTimeoutMs;
+		if (e === void 0 || this.sweepTimer !== void 0) return;
+		let t = Math.max(1e3, Math.floor(e / 4));
+		this.sweepTimer = setInterval(() => {
+			this.sweepIdle();
+		}, t), n(this.sweepTimer);
+	}
+	stopSweep() {
+		this.sweepTimer !== void 0 && (clearInterval(this.sweepTimer), this.sweepTimer = void 0);
+	}
+	start(e, t, n) {
+		let r = n ?? (this.fill && ((e) => this.fill(t, e)));
+		if (!r) throw Error("SharedReadCache needs a fill, either on the cache or on the get() call");
+		let i = new AbortController(), a = {
+			promise: r(i.signal),
+			signals: /* @__PURE__ */ new Set(),
+			pinned: !1,
+			controller: i,
+			dispose: new AbortController(),
+			settled: !1,
+			counted: !0,
+			size: 0,
+			batch: this.batch,
+			lastTouched: Date.now(),
+			seq: this.stamp()
+		};
+		this.entries.set(e, a), this.pending++;
+		let o = () => {
+			a.settled = !0, this.detach(a), a.dispose.abort(), a.signals.clear();
+		};
+		return a.promise.then((t) => {
+			if (o(), this.entries.get(e) === a) {
+				let n = this.weigh(t);
+				n === void 0 ? this.entries.delete(e) : (a.lastTouched = Date.now(), this.settledCount++, a.size = n, this.total += n, this.charge(n), this.startSweep());
+			}
+			this.maybeEvict();
+		}, () => {
+			this.entries.get(e) === a && this.deleteKey(e), o(), this.maybeEvict();
+		}), a;
+	}
+	weigh(e) {
+		try {
+			let t = this.sizeOf(e);
+			return Number.isFinite(t) && t >= 0 ? t : void 0;
+		} catch {
+			return;
+		}
+	}
+	join(e, t) {
+		t === void 0 ? e.pinned = !0 : t.aborted ? !e.pinned && e.signals.size === 0 && e.controller.abort(t.reason) : typeof t.addEventListener == "function" ? e.signals.has(t) || (e.signals.add(t), t.addEventListener("abort", () => {
+			e.signals.delete(t), !e.pinned && e.signals.size === 0 && (e.controller.abort(t.reason), this.detach(e));
+		}, {
+			once: !0,
+			signal: e.dispose.signal
+		})) : e.pinned = !0;
+	}
+	deleteKey(e) {
+		let t = this.entries.get(e);
+		t && (this.entries.delete(e), this.detach(t), t.settled && this.settledCount--, this.total -= t.size, this.charge(-t.size));
+	}
+	detach(e) {
+		e.counted && (e.counted = !1, this.pending--);
+	}
+	charge(e) {
+		this.budget && this.membership && this.budget.charge(this.membership, e);
+	}
+	lruSpare() {
+		if (!(this.settledCount <= 1)) {
+			for (let [e, t] of this.entries) if (t.settled) return {
+				cacheKey: e,
+				seq: t.seq
+			};
+		}
+	}
+	release(e) {
+		this.deleteKey(e);
+	}
+	maybeEvict() {
+		(this.evictionPolicy === "lru" || this.pending === 0) && (this.evict(), this.evictionPolicy === "batch" && this.batch++, this.budget?.evict());
+	}
+	evict() {
+		if (this.limit !== Infinity) {
+			if (this.evictionPolicy === "batch") {
+				for (let [e, t] of this.entries) {
+					if (this.total <= this.limit) break;
+					t.batch !== this.batch && t.settled && this.deleteKey(e);
+				}
+				return;
+			}
+			if (!(this.total <= this.limit)) for (let [e, t] of this.entries) {
+				if (this.total <= this.limit || this.settledCount <= 1) break;
+				t.settled && this.deleteKey(e);
+			}
+		}
+	}
+};
+//#endregion
+export { r as t };