@gmod/bam 6.1.1 → 7.0.1

package/src/record.ts

@@ -1,7 +1,19 @@
 import Constants from './constants.ts'
 
 const SEQRET_DECODER = '=ACMGRSVTWYHKDBN'.split('')
-const CIGAR_DECODER = 'MIDNSHP=X???????'.split('')
+const ASCII_CIGAR_CODES = [
+  77, 73, 68, 78, 83, 72, 80, 61, 88, 63, 63, 63, 63, 63, 63, 63,
+]
+
+// const CIGAR_MATCH = 0
+const CIGAR_INS = 1
+// const CIGAR_DEL = 2
+const CIGAR_REF_SKIP = 3
+const CIGAR_SOFT_CLIP = 4
+const CIGAR_HARD_CLIP = 5
+// const CIGAR_PAD = 6
+// const CIGAR_EQUAL = 7
+// const CIGAR_DIFF = 8
 
 interface Bytes {
   start: number
@@ -12,12 +24,12 @@ interface Bytes {
 export default class BamRecord {
   public fileOffset: number
   private bytes: Bytes
-  #dataView: DataView
+  private _dataView: DataView
 
   constructor(args: { bytes: Bytes; fileOffset: number }) {
     this.bytes = args.bytes
     this.fileOffset = args.fileOffset
-    this.#dataView = new DataView(this.bytes.byteArray.buffer)
+    this._dataView = new DataView(this.bytes.byteArray.buffer)
   }
 
   get byteArray() {
@@ -26,15 +38,15 @@ export default class BamRecord {
 
   get flags() {
     return (
-      (this.#dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >> 16
+      (this._dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >> 16
     )
   }
   get ref_id() {
-    return this.#dataView.getInt32(this.bytes.start + 4, true)
+    return this._dataView.getInt32(this.bytes.start + 4, true)
   }
 
   get start() {
-    return this.#dataView.getInt32(this.bytes.start + 8, true)
+    return this._dataView.getInt32(this.bytes.start + 8, true)
   }
 
   get end() {
@@ -93,130 +105,98 @@ export default class BamRecord {
     const blockEnd = this.bytes.end
     const tags = {} as Record<string, unknown>
     while (p < blockEnd) {
-      const tag = String.fromCharCode(
-        this.byteArray[p]!,
-        this.byteArray[p + 1]!,
-      )
+      const tag =
+        String.fromCharCode(this.byteArray[p]!) +
+        String.fromCharCode(this.byteArray[p + 1]!)
       const type = String.fromCharCode(this.byteArray[p + 2]!)
       p += 3
 
-      if (type === 'A') {
-        tags[tag] = String.fromCharCode(this.byteArray[p]!)
-        p += 1
-      } else if (type === 'i') {
-        tags[tag] = this.#dataView.getInt32(p, true)
-        p += 4
-      } else if (type === 'I') {
-        tags[tag] = this.#dataView.getUint32(p, true)
-        p += 4
-      } else if (type === 'c') {
-        tags[tag] = this.#dataView.getInt8(p)
-        p += 1
-      } else if (type === 'C') {
-        tags[tag] = this.#dataView.getUint8(p)
-        p += 1
-      } else if (type === 's') {
-        tags[tag] = this.#dataView.getInt16(p, true)
-        p += 2
-      } else if (type === 'S') {
-        tags[tag] = this.#dataView.getUint16(p, true)
-        p += 2
-      } else if (type === 'f') {
-        tags[tag] = this.#dataView.getFloat32(p, true)
-        p += 4
-      } else if (type === 'Z' || type === 'H') {
-        const value = []
-        while (p <= blockEnd) {
-          const cc = this.byteArray[p++]!
-          if (cc !== 0) {
-            value.push(String.fromCharCode(cc))
-          } else {
-            break
-          }
-        }
-        tags[tag] = value.join('')
-      } else if (type === 'B') {
-        const cc = this.byteArray[p++]!
-        const Btype = String.fromCharCode(cc)
-        const limit = this.#dataView.getInt32(p, true)
-        p += 4
-        if (Btype === 'i') {
-          if (tag === 'CG') {
-            const value = []
-            for (let k = 0; k < limit; k++) {
-              const cigop = this.#dataView.getInt32(p, true)
-              const lop = cigop >> 4
-              const op = CIGAR_DECODER[cigop & 0xf]!
-              value.push(lop + op)
-              p += 4
-            }
-            tags[tag] = value.join('')
-          } else {
-            const value = []
-            for (let k = 0; k < limit; k++) {
-              value.push(this.#dataView.getInt32(p, true))
-              p += 4
-            }
-            tags[tag] = value
-          }
-        } else if (Btype === 'I') {
-          if (tag === 'CG') {
-            const value = []
-            for (let k = 0; k < limit; k++) {
-              const cigop = this.#dataView.getUint32(p, true)
-              const lop = cigop >> 4
-              const op = CIGAR_DECODER[cigop & 0xf]!
-              value.push(lop + op)
-              p += 4
-            }
-            tags[tag] = value.join('')
-          } else {
-            const value = []
-            for (let k = 0; k < limit; k++) {
-              value.push(this.#dataView.getUint32(p, true))
-              p += 4
-            }
-            tags[tag] = value
-          }
-        } else if (Btype === 's') {
-          const value = []
-          for (let k = 0; k < limit; k++) {
-            value.push(this.#dataView.getInt16(p, true))
-            p += 2
-          }
-          tags[tag] = value
-        } else if (Btype === 'S') {
-          const value = []
-          for (let k = 0; k < limit; k++) {
-            value.push(this.#dataView.getUint16(p, true))
-            p += 2
-          }
-          tags[tag] = value
-        } else if (Btype === 'c') {
+      switch (type) {
+        case 'A':
+          tags[tag] = String.fromCharCode(this.byteArray[p]!)
+          p += 1
+          break
+        case 'i':
+          tags[tag] = this._dataView.getInt32(p, true)
+          p += 4
+          break
+        case 'I':
+          tags[tag] = this._dataView.getUint32(p, true)
+          p += 4
+          break
+        case 'c':
+          tags[tag] = this._dataView.getInt8(p)
+          p += 1
+          break
+        case 'C':
+          tags[tag] = this._dataView.getUint8(p)
+          p += 1
+          break
+        case 's':
+          tags[tag] = this._dataView.getInt16(p, true)
+          p += 2
+          break
+        case 'S':
+          tags[tag] = this._dataView.getUint16(p, true)
+          p += 2
+          break
+        case 'f':
+          tags[tag] = this._dataView.getFloat32(p, true)
+          p += 4
+          break
+        case 'Z':
+        case 'H': {
           const value = []
-          for (let k = 0; k < limit; k++) {
-            value.push(this.#dataView.getInt8(p))
-            p += 1
-          }
-          tags[tag] = value
-        } else if (Btype === 'C') {
-          const value = []
-          for (let k = 0; k < limit; k++) {
-            value.push(this.#dataView.getUint8(p))
-            p += 1
+          while (p <= blockEnd) {
+            const cc = this.byteArray[p++]!
+            if (cc !== 0) {
+              value.push(String.fromCharCode(cc))
+            } else {
+              break
+            }
           }
-          tags[tag] = value
-        } else if (Btype === 'f') {
-          const value = []
-          for (let k = 0; k < limit; k++) {
-            value.push(this.#dataView.getFloat32(p, true))
-            p += 4
+          tags[tag] = value.join('')
+          break
+        }
+        case 'B': {
+          const cc = this.byteArray[p++]!
+          const Btype = String.fromCharCode(cc)
+          const limit = this._dataView.getInt32(p, true)
+          p += 4
+          if (Btype === 'i') {
+            const bytes = this.byteArray.slice(p, p + limit * 4)
+            tags[tag] = new Int32Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit * 4
+          } else if (Btype === 'I') {
+            const bytes = this.byteArray.slice(p, p + limit * 4)
+            tags[tag] = new Uint32Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit * 4
+          } else if (Btype === 's') {
+            const bytes = this.byteArray.slice(p, p + limit * 2)
+            tags[tag] = new Int16Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit * 2
+          } else if (Btype === 'S') {
+            const bytes = this.byteArray.slice(p, p + limit * 2)
+            tags[tag] = new Uint16Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit * 2
+          } else if (Btype === 'c') {
+            const bytes = this.byteArray.slice(p, p + limit)
+            tags[tag] = new Int8Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit
+          } else if (Btype === 'C') {
+            const bytes = this.byteArray.slice(p, p + limit)
+            tags[tag] = new Uint8Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit
+          } else if (Btype === 'f') {
+            const bytes = this.byteArray.slice(p, p + limit * 4)
+            tags[tag] = new Float32Array(bytes.buffer, bytes.byteOffset, limit)
+            p += limit * 4
           }
-          tags[tag] = value
+          break
         }
-      } else {
-        console.error('Unknown BAM tag type', type)
-        break
+        default:
+          console.error('Unknown BAM tag type', type)
+          break
       }
     }
     return tags
@@ -289,51 +269,57 @@ export default class BamRecord {
     if (this.isSegmentUnmapped()) {
       return {
         length_on_ref: 0,
-        CIGAR: '',
+        NUMERIC_CIGAR: new Uint32Array(0),
       }
     }
 
     const numCigarOps = this.num_cigar_ops
     let p = this.b0 + this.read_name_length
-    const CIGAR = []
 
     // check for CG tag by inspecting whether the CIGAR field contains a clip
     // that consumes entire seqLen
-    let cigop = this.#dataView.getInt32(p, true)
-    let lop = cigop >> 4
-    let op = CIGAR_DECODER[cigop & 0xf]
-    if (op === 'S' && lop === this.seq_length) {
+    const cigop = this._dataView.getInt32(p, true)
+    const lop = cigop >> 4
+    const op = cigop & 0xf
+    if (op === CIGAR_SOFT_CLIP && lop === this.seq_length) {
       // if there is a CG the second CIGAR field will be a N tag the represents
       // the length on ref
       p += 4
-      cigop = this.#dataView.getInt32(p, true)
-      lop = cigop >> 4
-      op = CIGAR_DECODER[cigop & 0xf]
-      if (op !== 'N') {
+      const cigop = this._dataView.getInt32(p, true)
+      const lop = cigop >> 4
+      const op = cigop & 0xf
+      if (op !== CIGAR_REF_SKIP) {
         console.warn('CG tag with no N tag')
       }
+      const cgArray = this.tags.CG as Uint32Array
       return {
-        CIGAR: this.tags.CG as string,
+        NUMERIC_CIGAR: cgArray,
         length_on_ref: lop,
       }
     } else {
+      const cigarBytes = this.byteArray.slice(p, p + numCigarOps * 4)
+      const cigarView = new Uint32Array(
+        cigarBytes.buffer,
+        cigarBytes.byteOffset,
+        numCigarOps,
+      )
       let lref = 0
       for (let c = 0; c < numCigarOps; ++c) {
-        cigop = this.#dataView.getInt32(p, true)
-        lop = cigop >> 4
-        op = CIGAR_DECODER[cigop & 0xf]!
-        CIGAR.push(lop + op)
+        const cigop = cigarView[c]!
+        const op = cigop & 0xf
         // soft clip, hard clip, and insertion don't count toward the length on
         // the reference
-        if (op !== 'H' && op !== 'S' && op !== 'I') {
-          lref += lop
+        if (
+          op !== CIGAR_HARD_CLIP &&
+          op !== CIGAR_SOFT_CLIP &&
+          op !== CIGAR_INS
+        ) {
+          lref += cigop >> 4
         }
-
-        p += 4
       }
 
       return {
-        CIGAR: CIGAR.join(''),
+        NUMERIC_CIGAR: cigarView,
         length_on_ref: lref,
       }
     }
@@ -343,8 +329,20 @@ export default class BamRecord {
     return this.cigarAndLength.length_on_ref
   }
 
+  get NUMERIC_CIGAR() {
+    return this.cigarAndLength.NUMERIC_CIGAR
+  }
+
   get CIGAR() {
-    return this.cigarAndLength.CIGAR
+    const numeric = this.NUMERIC_CIGAR
+    let result = ''
+    for (let i = 0, l = numeric.length; i < l; i++) {
+      const packed = numeric[i]!
+      const length = packed >> 4
+      const opCode = ASCII_CIGAR_CODES[packed & 0xf]!
+      result += length + String.fromCharCode(opCode)
+    }
+    return result
   }
 
   get num_cigar_ops() {
@@ -359,21 +357,30 @@ export default class BamRecord {
     return (this.seq_length + 1) >> 1
   }
 
-  get seq() {
+  get NUMERIC_SEQ() {
     const p = this.b0 + this.read_name_length + this.num_cigar_ops * 4
-    const seqBytes = this.num_seq_bytes
+    const seqBytes = this.byteArray.slice(p, p + this.num_seq_bytes)
+    return new Uint8Array(seqBytes.buffer, seqBytes.byteOffset, this.num_seq_bytes)
+  }
+
+  get seq() {
+    const numeric = this.NUMERIC_SEQ
     const len = this.seq_length
-    const buf = []
+    const buf = new Array(len)
     let i = 0
-    for (let j = 0; j < seqBytes; ++j) {
-      const sb = this.byteArray[p + j]!
-      buf.push(SEQRET_DECODER[(sb & 0xf0) >> 4])
-      i++
-      if (i < len) {
-        buf.push(SEQRET_DECODER[sb & 0x0f])
-        i++
-      }
+    const fullBytes = len >> 1
+
+    for (let j = 0; j < fullBytes; ++j) {
+      const sb = numeric[j]!
+      buf[i++] = SEQRET_DECODER[(sb & 0xf0) >> 4]
+      buf[i++] = SEQRET_DECODER[sb & 0x0f]
+    }
+
+    if (i < len) {
+      const sb = numeric[fullBytes]!
+      buf[i] = SEQRET_DECODER[(sb & 0xf0) >> 4]
     }
+
     return buf.join('')
   }
 
@@ -415,27 +422,27 @@ export default class BamRecord {
   }
 
   get bin_mq_nl() {
-    return this.#dataView.getInt32(this.bytes.start + 12, true)
+    return this._dataView.getInt32(this.bytes.start + 12, true)
   }
 
   get flag_nc() {
-    return this.#dataView.getInt32(this.bytes.start + 16, true)
+    return this._dataView.getInt32(this.bytes.start + 16, true)
   }
 
   get seq_length() {
-    return this.#dataView.getInt32(this.bytes.start + 20, true)
+    return this._dataView.getInt32(this.bytes.start + 20, true)
   }
 
   get next_refid() {
-    return this.#dataView.getInt32(this.bytes.start + 24, true)
+    return this._dataView.getInt32(this.bytes.start + 24, true)
   }
 
   get next_pos() {
-    return this.#dataView.getInt32(this.bytes.start + 28, true)
+    return this._dataView.getInt32(this.bytes.start + 28, true)
   }
 
   get template_length() {
-    return this.#dataView.getInt32(this.bytes.start + 32, true)
+    return this._dataView.getInt32(this.bytes.start + 32, true)
   }
 
   seqAt(idx: number): string | undefined {
@@ -491,3 +498,4 @@ cacheGetter(BamRecord, 'tags')
 cacheGetter(BamRecord, 'cigarAndLength')
 cacheGetter(BamRecord, 'seq')
 cacheGetter(BamRecord, 'qual')
+cacheGetter(BamRecord, 'end')

package/src/util.ts

@@ -2,51 +2,6 @@ import Chunk from './chunk.ts'
 import { longFromBytesToUnsigned } from './long.ts'
 import { Offset, VirtualOffset } from './virtualOffset.ts'
 
-export function timeout(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-/**
- * Properly check if the given AbortSignal is aborted.
- *
- * Per the standard, if the signal reads as aborted, this function throws
- * either a DOMException AbortError, or a regular error with a `code` attribute
- * set to `ERR_ABORTED`.
- *
- * For convenience, passing `undefined` is a no-op
- *
- * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
- * @returns nothing
- */
-export function checkAbortSignal(signal?: AbortSignal) {
-  if (!signal) {
-    return
-  }
-
-  if (signal.aborted) {
-    // console.log('bam aborted!')
-    if (typeof DOMException === 'undefined') {
-      const e = new Error('aborted')
-      // @ts-ignore
-      e.code = 'ERR_ABORTED'
-      throw e
-    } else {
-      throw new DOMException('aborted', 'AbortError')
-    }
-  }
-}
-
-/**
- * Skips to the next tick, then runs `checkAbortSignal`.
- * Await this to inside an otherwise synchronous loop to
- * provide a place to break when an abort signal is received.
- * @param {AbortSignal} signal
- */
-export async function abortBreakPoint(signal?: AbortSignal) {
-  await Promise.resolve()
-  checkAbortSignal(signal)
-}
-
 export function canMergeBlocks(chunk1: Chunk, chunk2: Chunk) {
   return (
     chunk2.minv.blockPosition - chunk1.maxv.blockPosition < 65000 &&
@@ -146,15 +101,12 @@ export function parseNameBytes(
   return { refNameToId, refIdToName }
 }
 
-export function sum(array: Uint8Array[]) {
-  let sum = 0
-  for (const entry of array) {
-    sum += entry.length
-  }
-  return sum
-}
 export function concatUint8Array(args: Uint8Array[]) {
-  const mergedArray = new Uint8Array(sum(args))
+  let totalLength = 0
+  for (const entry of args) {
+    totalLength += entry.length
+  }
+  const mergedArray = new Uint8Array(totalLength)
   let offset = 0
   for (const entry of args) {
     mergedArray.set(entry, offset)
@@ -164,9 +116,11 @@ export function concatUint8Array(args: Uint8Array[]) {
 }
 
 export async function gen2array<T>(gen: AsyncIterable<T[]>): Promise<T[]> {
-  let out: T[] = []
+  const out: T[] = []
   for await (const x of gen) {
-    out = out.concat(x)
+    for (const item of x) {
+      out.push(item)
+    }
   }
   return out
 }