@gmod/bam 7.1.1 → 7.1.3

package/src/csi.ts

@@ -215,12 +215,13 @@ export default class CSI extends IndexFile {
 
     const chunks = []
     // Find chunks in overlapping bins.  Leaf bins (< 4681) are not pruned
+    const { binIndex } = ba
     for (const [start, end] of overlappingBins) {
       for (let bin = start; bin <= end; bin++) {
-        if (ba.binIndex[bin]) {
-          const binChunks = ba.binIndex[bin]!
-          for (const c of binChunks) {
-            chunks.push(c)
+        const binChunks = binIndex[bin]
+        if (binChunks) {
+          for (let i = 0, l = binChunks.length; i < l; i++) {
+            chunks.push(binChunks[i]!)
           }
         }
       }

package/src/indexFile.ts

@@ -1,8 +1,14 @@
 import Chunk from './chunk.ts'
-import { BaseOpts } from './util.ts'
+import { BaseOpts, optimizeChunks } from './util.ts'
 
 import type { GenericFilehandle } from 'generic-filehandle2'
 
+export interface Region {
+  refId: number
+  start: number
+  end: number
+}
+
 export default abstract class IndexFile {
   public filehandle: GenericFilehandle
   public renameRefSeq: (s: string) => string
@@ -30,4 +36,19 @@ export default abstract class IndexFile {
     end: number,
     opts?: BaseOpts,
   ): Promise<Chunk[]>
+
+  async estimatedBytesForRegions(regions: Region[], opts?: BaseOpts) {
+    const blockResults = await Promise.all(
+      regions.map(r => this.blocksForRange(r.refId, r.start, r.end, opts)),
+    )
+
+    // Deduplicate and merge overlapping blocks across all regions
+    const mergedBlocks = optimizeChunks(blockResults.flat())
+
+    let total = 0
+    for (const block of mergedBlocks) {
+      total += block.fetchedSize()
+    }
+    return total
+  }
 }

package/src/record.ts

@@ -98,6 +98,68 @@ export default class BamRecord {
     return str
   }
 
+  get NUMERIC_MD() {
+    let p =
+      this.b0 +
+      this.read_name_length +
+      this.num_cigar_bytes +
+      this.num_seq_bytes +
+      this.seq_length
+
+    const blockEnd = this.bytes.end
+    while (p < blockEnd) {
+      const tag =
+        String.fromCharCode(this.byteArray[p]!) +
+        String.fromCharCode(this.byteArray[p + 1]!)
+      const type = String.fromCharCode(this.byteArray[p + 2]!)
+      p += 3
+
+      if (tag === 'MD' && type === 'Z') {
+        const start = p
+        while (p < blockEnd && this.byteArray[p] !== 0) {
+          p++
+        }
+        return this.byteArray.subarray(start, p)
+      }
+
+      switch (type) {
+        case 'A':
+          p += 1
+          break
+        case 'i':
+        case 'I':
+        case 'f':
+          p += 4
+          break
+        case 'c':
+        case 'C':
+          p += 1
+          break
+        case 's':
+        case 'S':
+          p += 2
+          break
+        case 'Z':
+        case 'H':
+          while (p <= blockEnd && this.byteArray[p++] !== 0) {}
+          break
+        case 'B': {
+          const Btype = String.fromCharCode(this.byteArray[p++]!)
+          const limit = this._dataView.getInt32(p, true)
+          p += 4
+          if (Btype === 'i' || Btype === 'I' || Btype === 'f') {
+            p += limit << 2
+          } else if (Btype === 's' || Btype === 'S') {
+            p += limit << 1
+          } else if (Btype === 'c' || Btype === 'C') {
+            p += limit
+          }
+          break
+        }
+      }
+    }
+    return undefined
+  }
   get tags() {
     let p =
       this.b0 +

package/src/util.ts

@@ -25,33 +25,68 @@ export function makeOpts(obj: AbortSignal | BaseOpts = {}): BaseOpts {
 }
 
 export function optimizeChunks(chunks: Chunk[], lowest?: Offset) {
-  const mergedChunks: Chunk[] = []
-  let lastChunk: Chunk | undefined
-
-  if (chunks.length === 0) {
+  const n = chunks.length
+  if (n === 0) {
     return chunks
   }
 
-  chunks.sort((c0, c1) => {
+  // Pre-filter chunks below lowest threshold before sorting
+  let filtered: Chunk[]
+  if (lowest) {
+    const lowestBlock = lowest.blockPosition
+    const lowestData = lowest.dataPosition
+    filtered = []
+    for (let i = 0; i < n; i++) {
+      const chunk = chunks[i]!
+      const maxv = chunk.maxv
+      const cmp =
+        maxv.blockPosition - lowestBlock || maxv.dataPosition - lowestData
+      if (cmp > 0) {
+        filtered.push(chunk)
+      }
+    }
+    if (filtered.length === 0) {
+      return filtered
+    }
+  } else {
+    filtered = chunks
+  }
+
+  filtered.sort((c0, c1) => {
     const dif = c0.minv.blockPosition - c1.minv.blockPosition
-    return dif === 0 ? c0.minv.dataPosition - c1.minv.dataPosition : dif
+    return dif !== 0 ? dif : c0.minv.dataPosition - c1.minv.dataPosition
   })
 
-  for (const chunk of chunks) {
-    if (!lowest || chunk.maxv.compareTo(lowest) > 0) {
-      if (lastChunk === undefined) {
-        mergedChunks.push(chunk)
-        lastChunk = chunk
-      } else {
-        if (canMergeBlocks(lastChunk, chunk)) {
-          if (chunk.maxv.compareTo(lastChunk.maxv) > 0) {
-            lastChunk.maxv = chunk.maxv
-          }
-        } else {
-          mergedChunks.push(chunk)
-          lastChunk = chunk
-        }
+  const mergedChunks: Chunk[] = []
+  let lastChunk = filtered[0]!
+  mergedChunks.push(lastChunk)
+
+  let lastMinBlock = lastChunk.minv.blockPosition
+  let lastMaxBlock = lastChunk.maxv.blockPosition
+
+  for (let i = 1; i < filtered.length; i++) {
+    const chunk = filtered[i]!
+    const chunkMinBlock = chunk.minv.blockPosition
+    const chunkMaxBlock = chunk.maxv.blockPosition
+    // Inlined canMergeBlocks: check if chunks are close enough to merge
+    if (
+      chunkMinBlock - lastMaxBlock < 65000 &&
+      chunkMaxBlock - lastMinBlock < 5000000
+    ) {
+      const chunkMaxv = chunk.maxv
+      const lastMaxv = lastChunk.maxv
+      const cmp =
+        chunkMaxBlock - lastMaxBlock ||
+        chunkMaxv.dataPosition - lastMaxv.dataPosition
+      if (cmp > 0) {
+        lastChunk.maxv = chunkMaxv
+        lastMaxBlock = chunkMaxBlock
       }
+    } else {
+      mergedChunks.push(chunk)
+      lastChunk = chunk
+      lastMinBlock = chunkMinBlock
+      lastMaxBlock = chunkMaxBlock
     }
   }