@gmod/bam 7.9.1 → 8.0.0

package/src/indexFile.ts

@@ -53,14 +53,14 @@ export default abstract class IndexFile<
   public filehandle: GenericFilehandle
   public renameRefSeq: (s: string) => string
 
-  private setupP?: Promise<TParsed>
+  private parseP?: Promise<TParsed>
   /**
-   * The signal `setupP` was started under, while it is still in flight. The
+   * The signal `parseP` was started under, while it is still in flight. The
    * index is parsed once and shared by every query against the file, so without
    * this the first query to arrive would own a read all the others depend on —
    * see {@link parse}.
    */
-  private setupSignal?: AbortSignal
+  private parseSignal?: AbortSignal
 
   constructor({
     filehandle,
@@ -128,6 +128,8 @@ export default abstract class IndexFile<
     return optimizeChunks(chunks, this.getLowestChunk(ba, min))
   }
 
+  // SYNC: ~/src/gmod/tabix-js/src/indexFile.ts parse — same owner-signal
+  // tracking and one-attempt retry, and the same reasoning below.
   /**
    * Parse the index, or join the parse already running.
    *
@@ -153,13 +155,13 @@ export default abstract class IndexFile<
    */
   async parse(opts: BaseOpts = {}, retried = false): Promise<TParsed> {
     throwIfAborted(opts.signal)
-    const pending = this.setupP
+    const pending = this.parseP
     if (!pending) {
       return this.startParse(opts)
     }
 
     // read before awaiting: the owner is forgotten as soon as the parse settles
-    const ownerSignal = this.setupSignal
+    const ownerSignal = this.parseSignal
     try {
       return await pending
     } catch (e) {
@@ -172,22 +174,22 @@ export default abstract class IndexFile<
 
   private startParse(opts: BaseOpts) {
     const pending = this._parse(opts)
-    this.setupP = pending
-    this.setupSignal = opts.signal
+    this.parseP = pending
+    this.parseSignal = opts.signal
     // Drop a rejection rather than keeping it, so one transient failure does not
     // poison the index for the lifetime of the file. Both branches are
     // identity-checked so a retry started after this settles is not cleared by
     // the attempt it already replaced.
     pending.then(
       () => {
-        if (this.setupP === pending) {
-          this.setupSignal = undefined
+        if (this.parseP === pending) {
+          this.parseSignal = undefined
         }
       },
       () => {
-        if (this.setupP === pending) {
-          this.setupP = undefined
-          this.setupSignal = undefined
+        if (this.parseP === pending) {
+          this.parseP = undefined
+          this.parseSignal = undefined
         }
       },
     )

package/src/util.ts

@@ -39,33 +39,10 @@ export interface BaseOpts {
  * underneath you. (The Chunk objects themselves are never mutated; a merged
  * span produces a new instance.)
  */
-/**
- * `signal.throwIfAborted()`, without requiring either that method or `reason`.
- *
- * Two reasons not to call the built-in directly. It assumes a *real*
- * `AbortSignal`, and callers pass duck-typed ones — `test/csi.test.ts` casts a
- * bare `{ aborted }` through `as AbortSignal`, which is a fair model of what
- * consumers do; calling a missing method there is a `TypeError` rather than the
- * cancellation the caller asked for, which is a strictly worse failure.
- *
- * And it sets a browser floor. `AbortSignal.prototype.throwIfAborted` and
- * `AbortSignal.reason` are Safari 15.4 / Chrome 100 / Firefox 97 (March 2022) —
- * higher than anything else in this dependency tree needs, since
- * `generic-filehandle2` only ever forwards a signal to `fetch`, and higher than
- * every sibling gmod library, which use plain `.aborted`. Three lines here
- * keeps that floor where it was.
- *
- * Faithful to the spec otherwise: an aborted signal throws its `reason`
- * whatever that is, and only synthesizes an `AbortError` when there is none.
- */
-export function throwIfAborted(signal?: AbortSignal) {
-  if (signal?.aborted) {
-    const { reason } = signal
-    throw reason === undefined
-      ? new DOMException('This operation was aborted', 'AbortError')
-      : reason
-  }
-}
+// Re-exported so the internal import path stays './util.ts'. The
+// implementation moved to @gmod/shared-read-cache, which needs it anyway --
+// every consumer of that package was carrying an identical copy.
+export { throwIfAborted } from '@gmod/shared-read-cache'
 
 export function optimizeChunks(chunks: Chunk[], lowest?: OffsetCoords) {
   const n = chunks.length