@gmod/hic 1.2.0 → 1.3.0

package/src/index.ts

@@ -4,6 +4,7 @@ export { readerFromFilehandle } from './reader.ts'
 export type { HicConfig } from './hicFile.ts'
 export type { ContactRecords } from './contactRecords.ts'
 export type {
+  BaseOpts,
   Chromosome,
   HicMetadata,
   HicRegion,

package/src/lru.ts

@@ -65,8 +65,6 @@ export default class LRU<K, V> {
     }
   }
 
-  // Used to evict a rejected in-flight promise so the next caller retries
-  // rather than resolving against a cached failure forever.
   delete(key: K) {
     const existing = this.map.get(key)
     if (existing !== undefined) {

package/src/normalizationVector.ts

@@ -1,6 +1,6 @@
 import BinaryParser from './binary.ts'
 
-import type { Reader } from './types.ts'
+import type { BaseOpts, Reader } from './types.ts'
 
 const DOUBLE = 8
 
@@ -25,7 +25,7 @@ export default class NormalizationVector {
     this.dataType = dataType
   }
 
-  async getValues(start: number, end: number) {
+  async getValues(start: number, end: number, opts?: BaseOpts) {
     // The read below clamps to `nValues`, so the cache can never cover past it.
     // Compare against the clamped bound or a request that runs off the end of
     // the vector — reachable when the assembly's refseq is longer than the size
@@ -33,11 +33,27 @@ export default class NormalizationVector {
     // forever, and every call re-reads the same range from the file.
     const wanted = Math.min(end, this.nValues)
     if (!this.cache || start < this.cache.start || wanted > this.cache.end) {
-      const adjustedStart = Math.max(0, start - 1000)
       const adjustedEnd = Math.min(this.nValues, end + 1000)
+      // Clamped against `adjustedEnd`, and not merely against zero, or a window
+      // starting past the vector produces a NEGATIVE `n` — and a negative read
+      // length reaches the reader as `new Uint8Array(-8)`, a RangeError that
+      // fails the whole fetch instead of the empty answer the caller below
+      // already handles. The padding is what sets how far past is far enough:
+      // more than 1000 bins, which at a fine binsize is not far at all.
+      //
+      // Reachable exactly where the comment above says: the assembly's refseq
+      // is longer than the size the `.hic` recorded for that chromosome, so a
+      // view of the tail of it asks for bins the vector never had.
+      const adjustedStart = Math.min(Math.max(0, start - 1000), adjustedEnd)
       const startPosition = this.filePosition + adjustedStart * this.dataType
       const n = adjustedEnd - adjustedStart
-      const data = await this.file.read(startPosition, n * this.dataType)
+      // Nothing to read when the window is entirely past the vector, and on a
+      // remote file a zero-length range request is still a round trip — one per
+      // region pair, on every fetch, for as long as the view stays there.
+      const data =
+        n > 0
+          ? await this.file.read(startPosition, n * this.dataType, opts)
+          : new ArrayBuffer(0)
       const parser = new BinaryParser(new DataView(data))
       const values = new Float64Array(n)
       for (let i = 0; i < n; i++) {

package/src/reader.ts

@@ -1,10 +1,12 @@
-import type { Reader } from './types.ts'
+import type { BaseOpts, Reader } from './types.ts'
 import type { GenericFilehandle } from 'generic-filehandle2'
 
 export function readerFromFilehandle(filehandle: GenericFilehandle): Reader {
   return {
-    async read(position: number, length: number) {
-      const buf = await filehandle.read(length, position)
+    async read(position: number, length: number, opts?: BaseOpts) {
+      const buf = await filehandle.read(length, position, {
+        signal: opts?.signal,
+      })
       return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
     },
   }

package/src/types.ts

@@ -4,9 +4,20 @@
  * reads past the end to discover whether a file carries normalization data at
  * all. `generic-filehandle2` handles behave this way (a remote 416 included),
  * and `readerFromFilehandle` adapts one to this shape.
+ *
+ * A reader that ignores `opts.signal` still cancels, only later: the parser
+ * checks the signal when a fetch of blocks lands.
  */
 export interface Reader {
-  read: (position: number, length: number) => Promise<ArrayBuffer>
+  read: (
+    position: number,
+    length: number,
+    opts?: BaseOpts,
+  ) => Promise<ArrayBuffer>
+}
+
+export interface BaseOpts {
+  signal?: AbortSignal
 }
 
 /**
@@ -30,7 +41,7 @@ export type ProgressCallback = (current: number, total: number) => void
  * belongs to the operation a caller is waiting on, and a file-wide callback
  * could not say which of several concurrent fetches it was describing.
  */
-export interface ProgressOpts {
+export interface ProgressOpts extends BaseOpts {
   onProgress?: ProgressCallback
 }