@gmod/bam 7.1.3 → 7.1.5

package/src/record.ts

@@ -1,3 +1,9 @@
+import {
+  CIGAR_HARD_CLIP,
+  CIGAR_INS,
+  CIGAR_REF_SKIP,
+  CIGAR_SOFT_CLIP,
+} from './cigar.ts'
 import Constants from './constants.ts'
 
 const SEQRET_DECODER = '=ACMGRSVTWYHKDBN'.split('')
@@ -5,19 +11,9 @@ 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
-
 // ops that don't consume reference: INS, SOFT_CLIP, HARD_CLIP
 const CIGAR_SKIP_MASK =
   (1 << CIGAR_INS) | (1 << CIGAR_SOFT_CLIP) | (1 << CIGAR_HARD_CLIP)
-// const CIGAR_EQUAL = 7
-// const CIGAR_DIFF = 8
 
 interface Bytes {
   start: number
@@ -25,11 +21,21 @@ interface Bytes {
   byteArray: Uint8Array
 }
 
+interface CIGAR_AND_LENGTH {
+  length_on_ref: number
+  NUMERIC_CIGAR: Uint32Array
+}
+
 export default class BamRecord {
   public fileOffset: number
   private bytes: Bytes
   private _dataView: DataView
 
+  private _cachedFlags?: number
+  private _cachedTags?: Record<string, unknown>
+  private _cachedCigarAndLength?: CIGAR_AND_LENGTH
+  private _cachedNUMERIC_MD?: Uint8Array | null
+
   constructor(args: { bytes: Bytes; fileOffset: number }) {
     this.bytes = args.bytes
     this.fileOffset = args.fileOffset
@@ -41,9 +47,12 @@ export default class BamRecord {
   }
 
   get flags() {
-    return (
-      (this._dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >> 16
-    )
+    if (this._cachedFlags === undefined) {
+      this._cachedFlags =
+        (this._dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >>
+        16
+    }
+    return this._cachedFlags
   }
   get ref_id() {
     return this._dataView.getInt32(this.bytes.start + 4, true)
@@ -72,15 +81,15 @@ export default class BamRecord {
 
   get qual() {
     if (this.isSegmentUnmapped()) {
-      return
+      return null
+    } else {
+      const p =
+        this.b0 +
+        this.read_name_length +
+        this.num_cigar_bytes +
+        this.num_seq_bytes
+      return this.byteArray.subarray(p, p + this.seq_length)
     }
-
-    const p =
-      this.b0 +
-      this.read_name_length +
-      this.num_cigar_bytes +
-      this.num_seq_bytes
-    return this.byteArray.subarray(p, p + this.seq_length)
   }
 
   get strand() {
@@ -99,68 +108,80 @@ export default class BamRecord {
   }
 
   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++
+    if (this._cachedNUMERIC_MD === undefined) {
+      let p =
+        this.b0 +
+        this.read_name_length +
+        this.num_cigar_bytes +
+        this.num_seq_bytes +
+        this.seq_length
+
+      const blockEnd = this.bytes.end
+      const ba = this.byteArray
+      while (p < blockEnd) {
+        const tag1 = ba[p]!
+        const tag2 = ba[p + 1]!
+        const type = ba[p + 2]!
+        p += 3
+
+        // 'M' = 0x4D, 'D' = 0x44, 'Z' = 0x5A
+        if (tag1 === 0x4d && tag2 === 0x44 && type === 0x5a) {
+          const start = p
+          while (p < blockEnd && ba[p] !== 0) {
+            p++
+          }
+          this._cachedNUMERIC_MD = ba.subarray(start, 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
+        switch (type) {
+          case 0x41: // 'A'
+            p += 1
+            break
+          case 0x69: // 'i'
+          case 0x49: // 'I'
+          case 0x66: // 'f'
+            p += 4
+            break
+          case 0x63: // 'c'
+          case 0x43: // 'C'
+            p += 1
+            break
+          case 0x73: // 's'
+          case 0x53: // 'S'
+            p += 2
+            break
+          case 0x5a: // 'Z'
+          case 0x48: // 'H'
+            while (p <= blockEnd && ba[p++] !== 0) {}
+            break
+          case 0x42: {
+            // 'B'
+            const Btype = ba[p++]!
+            const limit = this._dataView.getInt32(p, true)
+            p += 4
+            if (Btype === 0x69 || Btype === 0x49 || Btype === 0x66) {
+              p += limit << 2
+            } else if (Btype === 0x73 || Btype === 0x53) {
+              p += limit << 1
+            } else if (Btype === 0x63 || Btype === 0x43) {
+              p += limit
+            }
+            break
           }
-          break
         }
       }
     }
-    return undefined
+    return this._cachedNUMERIC_MD === null ? undefined : this._cachedNUMERIC_MD
   }
+
   get tags() {
+    if (this._cachedTags === undefined) {
+      this._cachedTags = this._computeTags()
+    }
+    return this._cachedTags
+  }
+
+  private _computeTags() {
     let p =
       this.b0 +
       this.read_name_length +
@@ -169,52 +190,52 @@ export default class BamRecord {
       this.seq_length
 
     const blockEnd = this.bytes.end
+    const ba = this.byteArray
     const tags = {} as Record<string, unknown>
     while (p < blockEnd) {
-      const tag =
-        String.fromCharCode(this.byteArray[p]!) +
-        String.fromCharCode(this.byteArray[p + 1]!)
-      const type = String.fromCharCode(this.byteArray[p + 2]!)
+      const tag = String.fromCharCode(ba[p]!, ba[p + 1]!)
+      const type = ba[p + 2]!
       p += 3
 
       switch (type) {
-        case 'A':
-          tags[tag] = String.fromCharCode(this.byteArray[p]!)
+        case 0x41: // 'A'
+          tags[tag] = String.fromCharCode(ba[p]!)
           p += 1
           break
-        case 'i':
+        case 0x69: // 'i'
           tags[tag] = this._dataView.getInt32(p, true)
           p += 4
           break
-        case 'I':
+        case 0x49: // 'I'
           tags[tag] = this._dataView.getUint32(p, true)
           p += 4
           break
-        case 'c':
+        case 0x63: // 'c'
           tags[tag] = this._dataView.getInt8(p)
           p += 1
           break
-        case 'C':
+        case 0x43: // 'C'
           tags[tag] = this._dataView.getUint8(p)
           p += 1
           break
-        case 's':
+        case 0x73: // 's'
           tags[tag] = this._dataView.getInt16(p, true)
           p += 2
           break
-        case 'S':
+        case 0x53: // 'S'
           tags[tag] = this._dataView.getUint16(p, true)
           p += 2
           break
-        case 'f':
+        case 0x66: // 'f'
           tags[tag] = this._dataView.getFloat32(p, true)
           p += 4
           break
-        case 'Z':
-        case 'H': {
+        case 0x5a: // 'Z'
+        case 0x48: {
+          // 'H'
           const value = []
           while (p <= blockEnd) {
-            const cc = this.byteArray[p++]!
+            const cc = ba[p++]!
             if (cc !== 0) {
               value.push(String.fromCharCode(cc))
             } else {
@@ -224,75 +245,62 @@ export default class BamRecord {
           tags[tag] = value.join('')
           break
         }
-        case 'B': {
-          const cc = this.byteArray[p++]!
-          const Btype = String.fromCharCode(cc)
+        case 0x42: {
+          // 'B'
+          const Btype = ba[p++]!
           const limit = this._dataView.getInt32(p, true)
           p += 4
-          const absOffset = this.byteArray.byteOffset + p
-          if (Btype === 'i') {
+          const absOffset = ba.byteOffset + p
+          if (Btype === 0x69) {
+            // 'i'
             if (absOffset % 4 === 0) {
-              tags[tag] = new Int32Array(
-                this.byteArray.buffer,
-                absOffset,
-                limit,
-              )
+              tags[tag] = new Int32Array(ba.buffer, absOffset, limit)
             } else {
-              const bytes = this.byteArray.slice(p, p + (limit << 2))
+              const bytes = ba.slice(p, p + (limit << 2))
               tags[tag] = new Int32Array(bytes.buffer, bytes.byteOffset, limit)
             }
             p += limit << 2
-          } else if (Btype === 'I') {
+          } else if (Btype === 0x49) {
+            // 'I'
             if (absOffset % 4 === 0) {
-              tags[tag] = new Uint32Array(
-                this.byteArray.buffer,
-                absOffset,
-                limit,
-              )
+              tags[tag] = new Uint32Array(ba.buffer, absOffset, limit)
             } else {
-              const bytes = this.byteArray.slice(p, p + (limit << 2))
+              const bytes = ba.slice(p, p + (limit << 2))
               tags[tag] = new Uint32Array(bytes.buffer, bytes.byteOffset, limit)
             }
             p += limit << 2
-          } else if (Btype === 's') {
+          } else if (Btype === 0x73) {
+            // 's'
             if (absOffset % 2 === 0) {
-              tags[tag] = new Int16Array(
-                this.byteArray.buffer,
-                absOffset,
-                limit,
-              )
+              tags[tag] = new Int16Array(ba.buffer, absOffset, limit)
             } else {
-              const bytes = this.byteArray.slice(p, p + (limit << 1))
+              const bytes = ba.slice(p, p + (limit << 1))
               tags[tag] = new Int16Array(bytes.buffer, bytes.byteOffset, limit)
             }
             p += limit << 1
-          } else if (Btype === 'S') {
+          } else if (Btype === 0x53) {
+            // 'S'
             if (absOffset % 2 === 0) {
-              tags[tag] = new Uint16Array(
-                this.byteArray.buffer,
-                absOffset,
-                limit,
-              )
+              tags[tag] = new Uint16Array(ba.buffer, absOffset, limit)
             } else {
-              const bytes = this.byteArray.slice(p, p + (limit << 1))
+              const bytes = ba.slice(p, p + (limit << 1))
               tags[tag] = new Uint16Array(bytes.buffer, bytes.byteOffset, limit)
             }
             p += limit << 1
-          } else if (Btype === 'c') {
-            tags[tag] = new Int8Array(this.byteArray.buffer, absOffset, limit)
+          } else if (Btype === 0x63) {
+            // 'c'
+            tags[tag] = new Int8Array(ba.buffer, absOffset, limit)
             p += limit
-          } else if (Btype === 'C') {
-            tags[tag] = new Uint8Array(this.byteArray.buffer, absOffset, limit)
+          } else if (Btype === 0x43) {
+            // 'C'
+            tags[tag] = new Uint8Array(ba.buffer, absOffset, limit)
             p += limit
-          } else if (Btype === 'f') {
+          } else if (Btype === 0x66) {
+            // 'f'
             if (absOffset % 4 === 0) {
-              tags[tag] = new Float32Array(
-                this.byteArray.buffer,
-                absOffset,
-                limit,
-              )
+              tags[tag] = new Float32Array(ba.buffer, absOffset, limit)
             } else {
-              const bytes = this.byteArray.slice(p, p + (limit << 2))
+              const bytes = ba.slice(p, p + (limit << 2))
               tags[tag] = new Float32Array(
                 bytes.buffer,
                 bytes.byteOffset,
@@ -311,70 +319,62 @@ export default class BamRecord {
     return tags
   }
 
-  /**
-   * @returns {boolean} true if the read is paired, regardless of whether both
-   * segments are mapped
-   */
   isPaired() {
     return !!(this.flags & Constants.BAM_FPAIRED)
   }
 
-  /** @returns {boolean} true if the read is paired, and both segments are mapped */
   isProperlyPaired() {
     return !!(this.flags & Constants.BAM_FPROPER_PAIR)
   }
 
-  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
   isSegmentUnmapped() {
     return !!(this.flags & Constants.BAM_FUNMAP)
   }
 
-  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
   isMateUnmapped() {
     return !!(this.flags & Constants.BAM_FMUNMAP)
   }
 
-  /** @returns {boolean} true if the read is mapped to the reverse strand */
   isReverseComplemented() {
     return !!(this.flags & Constants.BAM_FREVERSE)
   }
 
-  /** @returns {boolean} true if the mate is mapped to the reverse strand */
   isMateReverseComplemented() {
     return !!(this.flags & Constants.BAM_FMREVERSE)
   }
 
-  /** @returns {boolean} true if this is read number 1 in a pair */
   isRead1() {
     return !!(this.flags & Constants.BAM_FREAD1)
   }
 
-  /** @returns {boolean} true if this is read number 2 in a pair */
   isRead2() {
     return !!(this.flags & Constants.BAM_FREAD2)
   }
 
-  /** @returns {boolean} true if this is a secondary alignment */
   isSecondary() {
     return !!(this.flags & Constants.BAM_FSECONDARY)
   }
 
-  /** @returns {boolean} true if this read has failed QC checks */
   isFailedQc() {
     return !!(this.flags & Constants.BAM_FQCFAIL)
   }
 
-  /** @returns {boolean} true if the read is an optical or PCR duplicate */
   isDuplicate() {
     return !!(this.flags & Constants.BAM_FDUP)
   }
 
-  /** @returns {boolean} true if this is a supplementary alignment */
   isSupplementary() {
     return !!(this.flags & Constants.BAM_FSUPPLEMENTARY)
   }
 
   get cigarAndLength() {
+    if (this._cachedCigarAndLength === undefined) {
+      this._cachedCigarAndLength = this._computeCigarAndLength()
+    }
+    return this._cachedCigarAndLength
+  }
+
+  private _computeCigarAndLength() {
     if (this.isSegmentUnmapped()) {
       return {
         length_on_ref: 0,
@@ -405,29 +405,28 @@ export default class BamRecord {
         NUMERIC_CIGAR: cgArray,
         length_on_ref: lop,
       }
-    } else {
-      const absOffset = this.byteArray.byteOffset + p
-      const cigarView =
-        absOffset % 4 === 0
-          ? new Uint32Array(this.byteArray.buffer, absOffset, numCigarOps)
-          : new Uint32Array(
-              this.byteArray.slice(p, p + (numCigarOps << 2)).buffer,
-              0,
-              numCigarOps,
-            )
-      let lref = 0
-      for (let c = 0; c < numCigarOps; ++c) {
-        const cigop = cigarView[c]!
-        const op = cigop & 0xf
-        if (!((1 << op) & CIGAR_SKIP_MASK)) {
-          lref += cigop >> 4
-        }
+    }
+    const absOffset = this.byteArray.byteOffset + p
+    const cigarView =
+      absOffset % 4 === 0
+        ? new Uint32Array(this.byteArray.buffer, absOffset, numCigarOps)
+        : new Uint32Array(
+            this.byteArray.slice(p, p + (numCigarOps << 2)).buffer,
+            0,
+            numCigarOps,
+          )
+    let lref = 0
+    for (let c = 0; c < numCigarOps; ++c) {
+      const cigop = cigarView[c]!
+      const op = cigop & 0xf
+      if (!((1 << op) & CIGAR_SKIP_MASK)) {
+        lref += cigop >> 4
       }
+    }
 
-      return {
-        NUMERIC_CIGAR: cigarView,
-        length_on_ref: lref,
-      }
+    return {
+      NUMERIC_CIGAR: cigarView,
+      length_on_ref: lref,
     }
   }
 
@@ -469,12 +468,7 @@ export default class BamRecord {
 
   get NUMERIC_SEQ() {
     const p = this.b0 + this.read_name_length + this.num_cigar_bytes
-    const seqBytes = this.byteArray.subarray(p, p + this.num_seq_bytes)
-    return new Uint8Array(
-      seqBytes.buffer,
-      seqBytes.byteOffset,
-      this.num_seq_bytes,
-    )
+    return this.byteArray.subarray(p, p + this.num_seq_bytes)
   }
 
   get seq() {
@@ -588,28 +582,3 @@ export default class BamRecord {
     return data
   }
 }
-
-function cacheGetter<T>(ctor: { prototype: T }, prop: keyof T): void {
-  const desc = Object.getOwnPropertyDescriptor(ctor.prototype, prop)
-  if (!desc) {
-    throw new Error('OH NO, NO PROPERTY DESCRIPTOR')
-  }
-  // eslint-disable-next-line @typescript-eslint/unbound-method
-  const getter = desc.get
-  if (!getter) {
-    throw new Error('OH NO, NOT A GETTER')
-  }
-  Object.defineProperty(ctor.prototype, prop, {
-    get() {
-      const ret = getter.call(this)
-      Object.defineProperty(this, prop, { value: ret })
-      return ret
-    },
-  })
-}
-
-cacheGetter(BamRecord, 'tags')
-cacheGetter(BamRecord, 'cigarAndLength')
-cacheGetter(BamRecord, 'seq')
-cacheGetter(BamRecord, 'qual')
-cacheGetter(BamRecord, 'end')