@genome-spy/core 0.63.0 → 0.65.0

package/dist/bundle/{index-CCJIjehY.js → AbortablePromiseCache-CcuMrnn7.js}

@@ -1,7 +1,6 @@
-import { g as u } from "./_commonjsHelpers-DjF3Plf2.js";
-class f {
+class h {
 }
-class b {
+class d {
   constructor() {
     this.signals = /* @__PURE__ */ new Set(), this.abortController = new AbortController();
   }
@@ -11,7 +10,7 @@ class b {
    *  longer be abortable.
    */
   //@ts-ignore
-  addSignal(t = new f()) {
+  addSignal(t = new h()) {
     if (this.signal.aborted)
       throw new Error("cannot add a signal, already aborted!");
     this.signals.add(t), t.aborted ? this.handleAborted(t) : typeof t.addEventListener == "function" && t.addEventListener("abort", () => {
@@ -28,13 +27,13 @@ class b {
     this.abortController.abort();
   }
 }
-class g {
+class b {
   constructor() {
     this.callbacks = /* @__PURE__ */ new Set();
   }
   addCallback(t = () => {
   }) {
-    this.callbacks.add(t), t(this.currentMessage);
+    this.callbacks.add(t), this.currentMessage && t(this.currentMessage);
   }
   callback(t) {
     this.currentMessage = t;
@@ -42,7 +41,7 @@ class g {
       e(t);
   }
 }
-class l {
+class c {
   constructor({ fill: t, cache: e }) {
     if (typeof t != "function")
       throw new TypeError("must pass a fill function");
@@ -65,16 +64,16 @@ class l {
   evict(t, e) {
     this.cache.get(t) === e && this.cache.delete(t);
   }
-  fill(t, e, r, i) {
-    const s = new b(), c = new g();
-    c.addCallback(i);
+  fill(t, e, r, s) {
+    const o = new d(), i = new b();
+    i.addCallback(s);
     const a = {
-      aborter: s,
-      promise: this.fillCallback(e, s.signal, (h) => {
-        c.callback(h);
+      aborter: o,
+      promise: this.fillCallback(e, o.signal, (n) => {
+        i.callback(n);
       }),
       settled: !1,
-      statusReporter: c,
+      statusReporter: i,
       get aborted() {
         return this.aborter.signal.aborted;
       }
@@ -85,8 +84,8 @@ class l {
       a.settled = !0;
     }, () => {
       a.settled = !0, this.evict(t, a);
-    }).catch((h) => {
-      throw console.error(h), h;
+    }).catch((n) => {
+      throw console.error(n), n;
     }), this.cache.set(t, a);
   }
   static checkSinglePromise(t, e) {
@@ -94,8 +93,8 @@ class l {
       if (e != null && e.aborted)
         throw Object.assign(new Error("aborted"), { code: "ERR_ABORTED" });
     }
-    return t.then((i) => (r(), i), (i) => {
-      throw r(), i;
+    return t.then((s) => (r(), s), (s) => {
+      throw r(), s;
     });
   }
   has(t) {
@@ -113,12 +112,12 @@ class l {
    * @param {AbortSignal} [signal] optional AbortSignal object that aborts the request
    * @param {statusCallback} a callback to get the current status of a pending async operation
    */
-  get(t, e, r, i) {
+  get(t, e, r, s) {
     if (!r && e instanceof AbortSignal)
       throw new TypeError("second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?");
-    const s = this.cache.get(t);
-    return s ? s.aborted && !s.settled ? (this.evict(t, s), this.get(t, e, r, i)) : s.settled ? s.promise : (s.aborter.addSignal(r), s.statusReporter.addCallback(i), l.checkSinglePromise(s.promise, r)) : (this.fill(t, e, r, i), l.checkSinglePromise(
-      //see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#non-null-assertion-operator-postfix-
+    const o = this.cache.get(t);
+    return o ? o.aborted && !o.settled ? (this.evict(t, o), this.get(t, e, r, s)) : o.settled ? o.promise : (o.aborter.addSignal(r), o.statusReporter.addCallback(s), c.checkSinglePromise(o.promise, r)) : (this.fill(t, e, r, s), c.checkSinglePromise(
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       this.cache.get(t).promise,
       r
     ));
@@ -145,74 +144,6 @@ class l {
     return e;
   }
 }
-var n, d;
-function p() {
-  if (d) return n;
-  d = 1;
-  class o {
-    constructor(e = {}) {
-      if (!(e.maxSize && e.maxSize > 0))
-        throw new TypeError("`maxSize` must be a number greater than 0");
-      this.maxSize = e.maxSize, this.cache = /* @__PURE__ */ new Map(), this.oldCache = /* @__PURE__ */ new Map(), this._size = 0;
-    }
-    _set(e, r) {
-      this.cache.set(e, r), this._size++, this._size >= this.maxSize && (this._size = 0, this.oldCache = this.cache, this.cache = /* @__PURE__ */ new Map());
-    }
-    get(e) {
-      if (this.cache.has(e))
-        return this.cache.get(e);
-      if (this.oldCache.has(e)) {
-        const r = this.oldCache.get(e);
-        return this.oldCache.delete(e), this._set(e, r), r;
-      }
-    }
-    set(e, r) {
-      return this.cache.has(e) ? this.cache.set(e, r) : this._set(e, r), this;
-    }
-    has(e) {
-      return this.cache.has(e) || this.oldCache.has(e);
-    }
-    peek(e) {
-      if (this.cache.has(e))
-        return this.cache.get(e);
-      if (this.oldCache.has(e))
-        return this.oldCache.get(e);
-    }
-    delete(e) {
-      const r = this.cache.delete(e);
-      return r && this._size--, this.oldCache.delete(e) || r;
-    }
-    clear() {
-      this.cache.clear(), this.oldCache.clear(), this._size = 0;
-    }
-    *keys() {
-      for (const [e] of this)
-        yield e;
-    }
-    *values() {
-      for (const [, e] of this)
-        yield e;
-    }
-    *[Symbol.iterator]() {
-      for (const e of this.cache)
-        yield e;
-      for (const e of this.oldCache) {
-        const [r] = e;
-        this.cache.has(r) || (yield e);
-      }
-    }
-    get size() {
-      let e = 0;
-      for (const r of this.oldCache.keys())
-        this.cache.has(r) || e++;
-      return this._size + e;
-    }
-  }
-  return n = o, n;
-}
-var m = p();
-const C = /* @__PURE__ */ u(m);
 export {
-  l as A,
-  C as L
+  c as A
 };

package/dist/bundle/browser-txUcLy2H.js

@@ -0,0 +1,123 @@
+class d {
+  constructor(e) {
+    this.blob = e, this.size = e.size;
+  }
+  async read(e, r = 0) {
+    if (!e)
+      return new Uint8Array(0);
+    const t = r, a = t + e;
+    return new Uint8Array(await this.blob.slice(t, a).arrayBuffer());
+  }
+  async readFile(e) {
+    const r = typeof e == "string" ? e : e == null ? void 0 : e.encoding;
+    if (r === "utf8")
+      return this.blob.text();
+    if (r)
+      throw new Error(`unsupported encoding: ${r}`);
+    return new Uint8Array(await this.blob.arrayBuffer());
+  }
+  async stat() {
+    return { size: this.size };
+  }
+  async close() {
+  }
+}
+function h(n) {
+  return (typeof n == "object" && n !== null && "message" in n ? n.message : `${n}`).replace(/\.$/, "");
+}
+class u {
+  constructor(e, r = {}) {
+    this.baseOverrides = {}, this.url = e;
+    const t = r.fetch || globalThis.fetch.bind(globalThis);
+    r.overrides && (this.baseOverrides = r.overrides), this.fetchImplementation = t;
+  }
+  async fetch(e, r) {
+    let t;
+    try {
+      t = await this.fetchImplementation(e, r);
+    } catch (a) {
+      if (`${a}`.includes("Failed to fetch")) {
+        console.warn(`generic-filehandle: refetching ${e} to attempt to work around chrome CORS header caching bug`);
+        try {
+          t = await this.fetchImplementation(e, {
+            ...r,
+            cache: "reload"
+          });
+        } catch (i) {
+          throw new Error(`${h(i)} fetching ${e}`, { cause: i });
+        }
+      } else
+        throw new Error(`${h(a)} fetching ${e}`, { cause: a });
+    }
+    return t;
+  }
+  async read(e, r, t = {}) {
+    const { headers: a = {}, signal: i, overrides: c = {} } = t;
+    e < 1 / 0 ? a.range = `bytes=${r}-${r + e}` : e === 1 / 0 && r !== 0 && (a.range = `bytes=${r}-`);
+    const s = await this.fetch(this.url, {
+      ...this.baseOverrides,
+      ...c,
+      headers: {
+        ...a,
+        ...c.headers,
+        ...this.baseOverrides.headers
+      },
+      method: "GET",
+      redirect: "follow",
+      mode: "cors",
+      signal: i
+    });
+    if (!s.ok)
+      throw new Error(`HTTP ${s.status} fetching ${this.url}`);
+    if (s.status === 200 && r === 0 || s.status === 206) {
+      const l = await s.arrayBuffer(), f = s.headers.get("content-range"), o = /\/(\d+)$/.exec(f || "");
+      return o != null && o[1] && (this._stat = {
+        size: parseInt(o[1], 10)
+      }), new Uint8Array(l.slice(0, e));
+    }
+    throw s.status === 200 ? new Error(`${this.url} fetch returned status 200, expected 206`) : new Error(`HTTP ${s.status} fetching ${this.url}`);
+  }
+  async readFile(e = {}) {
+    let r, t;
+    typeof e == "string" ? (r = e, t = {}) : (r = e.encoding, t = e, delete t.encoding);
+    const { headers: a = {}, signal: i, overrides: c = {} } = t, s = await this.fetch(this.url, {
+      headers: a,
+      method: "GET",
+      redirect: "follow",
+      mode: "cors",
+      signal: i,
+      ...this.baseOverrides,
+      ...c
+    });
+    if (s.status !== 200)
+      throw new Error(`HTTP ${s.status} fetching ${this.url}`);
+    if (r === "utf8")
+      return s.text();
+    if (r)
+      throw new Error(`unsupported encoding: ${r}`);
+    return new Uint8Array(await s.arrayBuffer());
+  }
+  async stat() {
+    if (!this._stat && (await this.read(10, 0), !this._stat))
+      throw new Error(`unable to determine size of file at ${this.url}`);
+    return this._stat;
+  }
+  async close() {
+  }
+}
+class w {
+  readFile() {
+    throw new Error("unimplemented");
+  }
+  read() {
+    throw new Error("unimplemented");
+  }
+  close() {
+    throw new Error("unimplemented");
+  }
+}
+export {
+  d as BlobFile,
+  w as LocalFile,
+  u as RemoteFile
+};