@genome-spy/core 0.72.0 → 0.74.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2023 Kari Lavikka
+Copyright (c) 2018-2026 Kari Lavikka
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/bundle/AbortablePromiseCache-3gHJdF3E.js

@@ -0,0 +1,96 @@
+//#region ../../node_modules/@gmod/abortable-promise-cache/esm/AggregateAbortController.js
+var e = class {}, t = class {
+	constructor() {
+		this.signals = /* @__PURE__ */ new Set(), this.abortController = new AbortController();
+	}
+	addSignal(t = new e()) {
+		if (this.signal.aborted) throw Error("cannot add a signal, already aborted!");
+		this.signals.add(t), t.aborted ? this.handleAborted(t) : typeof t.addEventListener == "function" && t.addEventListener("abort", () => {
+			this.handleAborted(t);
+		});
+	}
+	handleAborted(e) {
+		this.signals.delete(e), this.signals.size === 0 && this.abortController.abort();
+	}
+	get signal() {
+		return this.abortController.signal;
+	}
+	abort() {
+		this.abortController.abort();
+	}
+}, n = class {
+	constructor() {
+		this.callbacks = /* @__PURE__ */ new Set();
+	}
+	addCallback(e = () => {}) {
+		this.callbacks.add(e), this.currentMessage && e(this.currentMessage);
+	}
+	callback(e) {
+		this.currentMessage = e;
+		for (let t of this.callbacks) t(e);
+	}
+}, r = class e {
+	constructor({ fill: e, cache: t }) {
+		if (typeof e != "function") throw TypeError("must pass a fill function");
+		if (typeof t != "object") throw TypeError("must pass a cache object");
+		if (typeof t.get != "function" || typeof t.set != "function" || typeof t.delete != "function") throw TypeError("cache must implement get(key), set(key, val), and and delete(key)");
+		this.cache = t, this.fillCallback = e;
+	}
+	static isAbortException(e) {
+		return e.name === "AbortError" || e.code === "ERR_ABORTED" || e.message === "AbortError: aborted" || e.message === "Error: aborted";
+	}
+	evict(e, t) {
+		this.cache.get(e) === t && this.cache.delete(e);
+	}
+	fill(e, r, i, a) {
+		let o = new t(), s = new n();
+		s.addCallback(a);
+		let c = {
+			aborter: o,
+			promise: this.fillCallback(r, o.signal, (e) => {
+				s.callback(e);
+			}),
+			settled: !1,
+			statusReporter: s,
+			get aborted() {
+				return this.aborter.signal.aborted;
+			}
+		};
+		c.aborter.addSignal(i), c.aborter.signal.addEventListener("abort", () => {
+			c.settled || this.evict(e, c);
+		}), c.promise.then(() => {
+			c.settled = !0;
+		}, () => {
+			c.settled = !0, this.evict(e, c);
+		}).catch((e) => {
+			throw console.error(e), e;
+		}), this.cache.set(e, c);
+	}
+	static checkSinglePromise(e, t) {
+		function n() {
+			if (t?.aborted) throw Object.assign(/* @__PURE__ */ Error("aborted"), { code: "ERR_ABORTED" });
+		}
+		return e.then((e) => (n(), e), (e) => {
+			throw n(), e;
+		});
+	}
+	has(e) {
+		return this.cache.has(e);
+	}
+	get(t, n, r, i) {
+		if (!r && n instanceof AbortSignal) throw TypeError("second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?");
+		let a = this.cache.get(t);
+		return a ? a.aborted && !a.settled ? (this.evict(t, a), this.get(t, n, r, i)) : a.settled ? a.promise : (a.aborter.addSignal(r), a.statusReporter.addCallback(i), e.checkSinglePromise(a.promise, r)) : (this.fill(t, n, r, i), e.checkSinglePromise(this.cache.get(t).promise, r));
+	}
+	delete(e) {
+		let t = this.cache.get(e);
+		t && (t.settled || t.aborter.abort(), this.cache.delete(e));
+	}
+	clear() {
+		let e = this.cache.keys(), t = 0;
+		for (let n = e.next(); !n.done; n = e.next()) this.delete(n.value), t += 1;
+		return t;
+	}
+};
+//#endregion
+export { r as t };

package/dist/bundle/browser-BTgw5ieH.js

@@ -0,0 +1,126 @@
+import { t as e } from "./chunk-DmhlhrBa.js";
+//#region ../../node_modules/generic-filehandle2/esm/blobFile.js
+var t = class {
+	constructor(e) {
+		this.blob = e;
+	}
+	async read(e, t = 0) {
+		if (!e) return new Uint8Array();
+		let n = t, r = n + e, i = this.blob.slice(n, r);
+		return i.bytes ? i.bytes() : new Uint8Array(await i.arrayBuffer());
+	}
+	async readFile(e) {
+		let t = typeof e == "string" ? e : e?.encoding;
+		if (t === "utf8") return this.blob.text();
+		if (t) throw Error(`unsupported encoding: ${t}`);
+		return this.blob.bytes ? this.blob.bytes() : new Uint8Array(await this.blob.arrayBuffer());
+	}
+	async stat() {
+		return { size: this.blob.size };
+	}
+	async close() {}
+};
+//#endregion
+//#region ../../node_modules/generic-filehandle2/esm/remoteFile.js
+function n(e) {
+	return (typeof e == "object" && e && "message" in e ? e.message : `${e}`).replace(/\.$/, "");
+}
+var r = class {
+	constructor(e, t = {}) {
+		this.baseOverrides = {}, this.url = e;
+		let n = t.fetch || globalThis.fetch.bind(globalThis);
+		t.overrides && (this.baseOverrides = t.overrides), this.fetchImplementation = n;
+	}
+	async fetch(e, t) {
+		let r = (t) => Error(`${n(t)} fetching ${e}`, { cause: t }), i;
+		try {
+			i = await this.fetchImplementation(e, t);
+		} catch (n) {
+			if (`${n}`.includes("Failed to fetch")) {
+				console.warn(`generic-filehandle: refetching ${e} to attempt to work around chrome CORS header caching bug`);
+				try {
+					i = await this.fetchImplementation(e, {
+						...t,
+						cache: "reload"
+					});
+				} catch (e) {
+					throw r(e);
+				}
+			} else throw r(n);
+		}
+		return i;
+	}
+	async read(e, t, n = {}) {
+		if (e === 0) return new Uint8Array();
+		let { headers: r = {}, signal: i, overrides: a = {} } = n;
+		e < Infinity ? r.range = `bytes=${t}-${t + e - 1}` : e === Infinity && t !== 0 && (r.range = `bytes=${t}-`);
+		let o = await this.fetch(this.url, {
+			...this.baseOverrides,
+			...a,
+			headers: {
+				...this.baseOverrides.headers,
+				...a.headers,
+				...r
+			},
+			method: "GET",
+			redirect: "follow",
+			mode: "cors",
+			signal: i
+		});
+		if (!o.ok) throw Error(`HTTP ${o.status} fetching ${this.url}`);
+		if (o.status === 200 && t === 0 || o.status === 206) {
+			let t = o.headers.get("content-range"), n = /\/(\d+)$/.exec(t || "");
+			n?.[1] && (this._stat = { size: parseInt(n[1], 10) });
+			let r = o.bytes ? await o.bytes() : new Uint8Array(await o.arrayBuffer());
+			return r.byteLength <= e ? r : r.subarray(0, e);
+		}
+		throw Error(o.status === 200 ? `${this.url} fetch returned status 200, expected 206` : `HTTP ${o.status} fetching ${this.url}`);
+	}
+	async readFile(e = {}) {
+		let t, n;
+		if (typeof e == "string") t = e, n = {};
+		else {
+			t = e.encoding;
+			let { encoding: r, ...i } = e;
+			n = i;
+		}
+		let { headers: r = {}, signal: i, overrides: a = {} } = n, o = await this.fetch(this.url, {
+			...this.baseOverrides,
+			...a,
+			headers: {
+				...this.baseOverrides.headers,
+				...a.headers,
+				...r
+			},
+			method: "GET",
+			redirect: "follow",
+			mode: "cors",
+			signal: i
+		});
+		if (!o.ok) throw Error(`HTTP ${o.status} fetching ${this.url}`);
+		if (t === "utf8") return o.text();
+		if (t) throw Error(`unsupported encoding: ${t}`);
+		return o.bytes ? o.bytes() : new Uint8Array(await o.arrayBuffer());
+	}
+	async stat() {
+		if (!this._stat && (await this.read(10, 0), !this._stat)) throw Error(`unable to determine size of file at ${this.url}`);
+		return this._stat;
+	}
+	async close() {}
+}, i = /* @__PURE__ */ e({
+	BlobFile: () => t,
+	LocalFile: () => a,
+	RemoteFile: () => r
+}), a = class {
+	readFile() {
+		throw Error("unimplemented");
+	}
+	read() {
+		throw Error("unimplemented");
+	}
+	close() {
+		throw Error("unimplemented");
+	}
+};
+//#endregion
+export { i as n, r, a as t };

package/dist/bundle/chunk-DmhlhrBa.js

@@ -0,0 +1,11 @@
+//#region \0rolldown/runtime.js
+var e = Object.defineProperty, t = (t, n) => {
+	let r = {};
+	for (var i in t) e(r, i, {
+		get: t[i],
+		enumerable: !0
+	});
+	return n || e(r, Symbol.toStringTag, { value: "Module" }), r;
+};
+//#endregion
+export { t };