@gmod/tabix 3.0.5 → 3.1.1

package/src/chunk.ts

@@ -11,7 +11,7 @@ export default class Chunk {
     minv: VirtualOffset,
     maxv: VirtualOffset,
     bin: number,
-    fetchedSize = undefined,
+    fetchedSize?: number,
   ) {
     this.minv = minv
     this.maxv = maxv

package/src/csi.ts

@@ -68,7 +68,7 @@ export default class CSI extends IndexFile {
       end: dataView.getInt32(offset + 12, true),
     }
     const metaValue = dataView.getInt32(offset + 16, true)
-    const metaChar = metaValue ? String.fromCharCode(metaValue) : null
+    const metaChar = metaValue ? String.fromCharCode(metaValue) : undefined
     const skipLines = dataView.getInt32(offset + 20, true)
     const nameSectionLength = dataView.getInt32(offset + 24, true)
 
@@ -87,33 +87,6 @@ export default class CSI extends IndexFile {
     }
   }
 
-  _parseNameBytes(namesBytes: Uint8Array) {
-    let currRefId = 0
-    let currNameStart = 0
-    const refIdToName = []
-    const refNameToId: Record<string, number> = {}
-    const decoder = new TextDecoder('utf8')
-    for (let i = 0; i < namesBytes.length; i += 1) {
-      if (!namesBytes[i]) {
-        if (currNameStart < i) {
-          const refName = this.renameRefSeq(
-            decoder.decode(namesBytes.subarray(currNameStart, i)),
-          )
-          refIdToName[currRefId] = refName
-          refNameToId[refName] = currRefId
-        }
-        currNameStart = i + 1
-        currRefId += 1
-      }
-    }
-    return {
-      refNameToId,
-      refIdToName,
-    }
-  }
-
-  // fetch and parse the index
-
   async _parse(opts: Options = {}) {
     const bytes = await unzip(await this.filehandle.readFile(opts))
     const dataView = new DataView(bytes.buffer)
@@ -139,7 +112,7 @@ export default class CSI extends IndexFile {
         : {
             refIdToName: [],
             refNameToId: {},
-            metaChar: null,
+            metaChar: undefined,
             columnNumbers: { ref: 0, start: 1, end: 2 },
             coordinateType: 'zero-based-half-open',
             format: 'generic',

package/src/indexFile.ts

@@ -10,7 +10,7 @@ export interface Options {
 export interface IndexData {
   refNameToId: Record<string, number>
   refIdToName: string[]
-  metaChar: string | null
+  metaChar: string | undefined
   columnNumbers: { ref: number; start: number; end: number }
   coordinateType: string
   format: string
@@ -64,9 +64,9 @@ export default abstract class IndexFile {
 
   async parse(opts: Options = {}) {
     if (!this.parseP) {
-      this.parseP = this._parse(opts).catch((e: unknown) => {
+      this.parseP = this._parse(opts).catch((error: unknown) => {
         this.parseP = undefined
-        throw e
+        throw error
       })
     }
     return this.parseP
@@ -76,4 +76,29 @@ export default abstract class IndexFile {
     const idx = await this.parse(opts)
     return !!idx.indices[seqId]?.binIndex
   }
+
+  _parseNameBytes(namesBytes: Uint8Array) {
+    let currRefId = 0
+    let currNameStart = 0
+    const refIdToName: string[] = []
+    const refNameToId: Record<string, number> = {}
+    const decoder = new TextDecoder('utf8')
+    for (let i = 0; i < namesBytes.length; i += 1) {
+      if (!namesBytes[i]) {
+        if (currNameStart < i) {
+          const refName = this.renameRefSeq(
+            decoder.decode(namesBytes.subarray(currNameStart, i)),
+          )
+          refIdToName[currRefId] = refName
+          refNameToId[refName] = currRefId
+        }
+        currNameStart = i + 1
+        currRefId += 1
+      }
+    }
+    return {
+      refNameToId,
+      refIdToName,
+    }
+  }
 }

package/src/tabixIndexedFile.ts

@@ -11,11 +11,6 @@ import { checkAbortSignal } from './util.ts'
 
 import type { GenericFilehandle } from 'generic-filehandle2'
 
-function isASCII(str: string) {
-  // eslint-disable-next-line no-control-regex
-  return /^[\u0000-\u007F]*$/.test(str)
-}
-
 type GetLinesCallback = (line: string, fileOffset: number) => void
 
 interface GetLinesOpts {
@@ -35,6 +30,9 @@ export default class TabixIndexedFile {
   private index: IndexFile
   private renameRefSeq: (n: string) => string
   private chunkCache: AbortablePromiseCache<Chunk, ReadChunk>
+  public cache = new LRU<string, { buffer: Uint8Array; nextIn: number }>({
+    maxSize: 1000,
+  })
 
   /**
    * @param {object} args
@@ -161,6 +159,21 @@ export default class TabixIndexedFile {
    * @returns promise that is resolved when the whole read is finished,
    * rejected on error
    */
+  private calculateFileOffset(
+    cpositions: number[],
+    dpositions: number[],
+    pos: number,
+    blockStart: number,
+    minvDataPosition: number,
+  ) {
+    return (
+      cpositions[pos]! * (1 << 8) +
+      (blockStart - dpositions[pos]!) +
+      minvDataPosition +
+      1
+    )
+  }
+
   async getLines(
     refName: string,
     s: number | undefined,
@@ -209,69 +222,104 @@ export default class TabixIndexedFile {
       let pos = 0
 
       // fast path, Buffer is just ASCII chars and not gigantor, can be
-      // converted to string and processed directly. if it is not ASCII or
-      // gigantic (chrome max str len is 512Mb), we have to decode line by line
+      // converted to string and processed directly.
+      //
+      // if it is not ASCII or, we have to decode line by line, as it is
+      // otherwise hard to get the right 'fileOffset' based feature IDs
+      //
+      // we use a basic check for isASCII: string length equals buffer length
+      // if it is ASCII...no multi-byte decodings
       const str = decoder.decode(buffer)
-      const strIsASCII = isASCII(str)
-      while (blockStart < str.length) {
-        let line: string
-        let n: number
-        if (strIsASCII) {
-          n = str.indexOf('\n', blockStart)
+      const strIsASCII = buffer.length == str.length
+      if (strIsASCII) {
+        while (blockStart < str.length) {
+          const n = str.indexOf('\n', blockStart)
           if (n === -1) {
             break
           }
-          line = str.slice(blockStart, n)
-        } else {
-          n = buffer.indexOf('\n'.charCodeAt(0), blockStart)
+          const line = str.slice(blockStart, n)
+
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (dpositions) {
+            const target = blockStart + c.minv.dataPosition
+            while (pos < dpositions.length && target >= dpositions[pos]!) {
+              pos++
+            }
+          }
+
+          // filter the line for whether it is within the requested range
+          const { startCoordinate, overlaps } = this.checkLine(
+            metadata,
+            refName,
+            start,
+            end,
+            line,
+          )
+
+          if (overlaps) {
+            callback(
+              line,
+              this.calculateFileOffset(
+                cpositions,
+                dpositions,
+                pos,
+                blockStart,
+                c.minv.dataPosition,
+              ),
+            )
+          } else if (startCoordinate !== undefined && startCoordinate >= end) {
+            // the lines were overlapping the region, but now have stopped, so we
+            // must be at the end of the relevant data and we can stop processing
+            // data now
+            return
+          }
+          blockStart = n + 1
+        }
+      } else {
+        while (blockStart < buffer.length) {
+          const n = buffer.indexOf('\n'.charCodeAt(0), blockStart)
           if (n === -1) {
             break
           }
           const b = buffer.slice(blockStart, n)
-          line = decoder.decode(b)
-        }
+          const line = decoder.decode(b)
 
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (dpositions) {
-          while (blockStart + c.minv.dataPosition >= dpositions[pos++]!) {}
-          pos--
-        }
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (dpositions) {
+            const target = blockStart + c.minv.dataPosition
+            while (pos < dpositions.length && target >= dpositions[pos]!) {
+              pos++
+            }
+          }
 
-        // filter the line for whether it is within the requested range
-        const { startCoordinate, overlaps } = this.checkLine(
-          metadata,
-          refName,
-          start,
-          end,
-          line,
-        )
-
-        if (overlaps) {
-          callback(
+          // filter the line for whether it is within the requested range
+          const { startCoordinate, overlaps } = this.checkLine(
+            metadata,
+            refName,
+            start,
+            end,
             line,
-            // cpositions[pos] refers to actual file offset of a bgzip block
-            // boundaries
-            //
-            // we multiply by (1 <<8) in order to make sure each block has a
-            // "unique" address space so that data in that block could never
-            // overlap
-            //
-            // then the blockStart-dpositions is an uncompressed file offset
-            // from that bgzip block boundary, and since the cpositions are
-            // multiplied by (1 << 8) these uncompressed offsets get a unique
-            // space
-            cpositions[pos]! * (1 << 8) +
-              (blockStart - dpositions[pos]!) +
-              c.minv.dataPosition +
-              1,
           )
-        } else if (startCoordinate !== undefined && startCoordinate >= end) {
-          // the lines were overlapping the region, but now have stopped, so we
-          // must be at the end of the relevant data and we can stop processing
-          // data now
-          return
+
+          if (overlaps) {
+            callback(
+              line,
+              this.calculateFileOffset(
+                cpositions,
+                dpositions,
+                pos,
+                blockStart,
+                c.minv.dataPosition,
+              ),
+            )
+          } else if (startCoordinate !== undefined && startCoordinate >= end) {
+            // the lines were overlapping the region, but now have stopped, so we
+            // must be at the end of the relevant data and we can stop processing
+            // data now
+            return
+          }
+          blockStart = n + 1
         }
-        blockStart = n + 1
       }
     }
   }
@@ -303,11 +351,13 @@ export default class TabixIndexedFile {
       let lastNewline = -1
       const newlineByte = '\n'.charCodeAt(0)
       const metaByte = metaChar.charCodeAt(0)
-      for (let i = 0; i < bytes.length; i += 1) {
-        if (i === lastNewline + 1 && bytes[i] !== metaByte) {
+
+      for (let i = 0, l = bytes.length; i < l; i++) {
+        const byte = bytes[i]
+        if (i === lastNewline + 1 && byte !== metaByte) {
           break
         }
-        if (bytes[i] === newlineByte) {
+        if (byte === newlineByte) {
           lastNewline = i
         }
       }
@@ -402,7 +452,10 @@ export default class TabixIndexedFile {
             }
           }
         } else if (currentColumnNumber === start) {
-          startCoordinate = parseInt(line.slice(currentColumnStart, i), 10)
+          startCoordinate = Number.parseInt(
+            line.slice(currentColumnStart, i),
+            10,
+          )
           // we convert to 0-based-half-open
           if (coordinateType === '1-based-closed') {
             startCoordinate -= 1
@@ -413,13 +466,13 @@ export default class TabixIndexedFile {
               overlaps: false,
             }
           }
-          if (end === 0 || end === start) {
-            // if we have no end, we assume the feature is 1 bp long
-            if (startCoordinate + 1 <= regionStart) {
-              return {
-                startCoordinate,
-                overlaps: false,
-              }
+          if (
+            (end === 0 || end === start) && // if we have no end, we assume the feature is 1 bp long
+            startCoordinate + 1 <= regionStart
+          ) {
+            return {
+              startCoordinate,
+              overlaps: false,
             }
           }
         } else if (format === 'VCF' && currentColumnNumber === 4) {
@@ -440,11 +493,11 @@ export default class TabixIndexedFile {
             }
           }
         }
-        currentColumnStart = i + 1
-        currentColumnNumber += 1
-        if (currentColumnNumber > maxColumn) {
+        if (currentColumnNumber === maxColumn) {
           break
         }
+        currentColumnStart = i + 1
+        currentColumnNumber += 1
       }
     }
     return {
@@ -462,17 +515,10 @@ export default class TabixIndexedFile {
     // be another pairwise feature at the end of this one
     const isTRA = info.includes('SVTYPE=TRA')
     if (info[0] !== '.' && !isTRA) {
-      let prevChar = ';'
-      for (let j = 0; j < info.length; j += 1) {
-        if (prevChar === ';' && info.slice(j, j + 4) === 'END=') {
-          let valueEnd = info.indexOf(';', j)
-          if (valueEnd === -1) {
-            valueEnd = info.length
-          }
-          endCoordinate = parseInt(info.slice(j + 4, valueEnd), 10)
-          break
-        }
-        prevChar = info[j]
+      const endRegex = /(?:^|;)END=([^;]+)/
+      const match = endRegex.exec(info)
+      if (match) {
+        endCoordinate = Number.parseInt(match[1]!, 10)
       }
     } else if (isTRA) {
       return startCoordinate + 1
@@ -502,6 +548,6 @@ export default class TabixIndexedFile {
       c.minv.blockPosition,
       opts,
     )
-    return unzipChunkSlice(ret, c)
+    return unzipChunkSlice(ret, c, this.cache)
   }
 }

package/src/tbi.ts

@@ -75,7 +75,7 @@ export default class TabixIndex extends IndexFile {
     const depth = 5
     const maxBinNumber = ((1 << ((depth + 1) * 3)) - 1) / 7
     const maxRefLength = 2 ** (14 + depth * 3)
-    const metaChar = metaValue ? String.fromCharCode(metaValue) : null
+    const metaChar = metaValue ? String.fromCharCode(metaValue) : undefined
     const skipLines = dataView.getInt32(28, true)
 
     // read sequence dictionary
@@ -160,31 +160,6 @@ export default class TabixIndex extends IndexFile {
     }
   }
 
-  _parseNameBytes(namesBytes: Uint8Array) {
-    let currRefId = 0
-    let currNameStart = 0
-    const refIdToName: string[] = []
-    const refNameToId: Record<string, number> = {}
-    const decoder = new TextDecoder('utf8')
-    for (let i = 0; i < namesBytes.length; i += 1) {
-      if (!namesBytes[i]) {
-        if (currNameStart < i) {
-          const refName = this.renameRefSeq(
-            decoder.decode(namesBytes.subarray(currNameStart, i)),
-          )
-          refIdToName[currRefId] = refName
-          refNameToId[refName] = currRefId
-        }
-        currNameStart = i + 1
-        currRefId += 1
-      }
-    }
-    return {
-      refNameToId,
-      refIdToName,
-    }
-  }
-
   async blocksForRange(
     refName: string,
     min: number,
@@ -205,13 +180,14 @@ export default class TabixIndex extends IndexFile {
       return []
     }
 
-    const minOffset = ba.linearIndex.length
-      ? ba.linearIndex[
-          min >> TAD_LIDX_SHIFT >= ba.linearIndex.length
-            ? ba.linearIndex.length - 1
-            : min >> TAD_LIDX_SHIFT
-        ]
-      : new VirtualOffset(0, 0)
+    const minOffset =
+      ba.linearIndex.length > 0
+        ? ba.linearIndex[
+            min >> TAD_LIDX_SHIFT >= ba.linearIndex.length
+              ? ba.linearIndex.length - 1
+              : min >> TAD_LIDX_SHIFT
+          ]
+        : new VirtualOffset(0, 0)
     if (!minOffset) {
       console.warn('querying outside of possible tabix range')
     }
@@ -235,15 +211,13 @@ export default class TabixIndex extends IndexFile {
     // Use the linear index to find minimum file position of chunks that could
     // contain alignments in the region
     const nintv = ba.linearIndex.length
-    let lowest = null
+    let lowest: VirtualOffset | undefined
     const minLin = Math.min(min >> 14, nintv - 1)
     const maxLin = Math.min(max >> 14, nintv - 1)
     for (let i = minLin; i <= maxLin; ++i) {
       const vp = ba.linearIndex[i]
-      if (vp) {
-        if (!lowest || vp.compareTo(lowest) < 0) {
-          lowest = vp
-        }
+      if (vp && (!lowest || vp.compareTo(lowest) < 0)) {
+        lowest = vp
       }
     }
 

package/src/util.ts

@@ -22,12 +22,12 @@ export function checkAbortSignal(signal?: AbortSignal) {
   }
 
   if (signal.aborted) {
-    if (typeof DOMException !== 'undefined') {
-      throw new DOMException('aborted', 'AbortError')
-    } else {
+    if (typeof DOMException === 'undefined') {
       const e = new AbortError('aborted')
       e.code = 'ERR_ABORTED'
       throw e
+    } else {
+      throw new DOMException('aborted', 'AbortError')
     }
   }
 }
@@ -52,7 +52,7 @@ export function canMergeBlocks(chunk1: Chunk, chunk2: Chunk) {
 
 export function optimizeChunks(chunks: Chunk[], lowest?: VirtualOffset) {
   const mergedChunks: Chunk[] = []
-  let lastChunk: Chunk | null = null
+  let lastChunk: Chunk | undefined
 
   if (chunks.length === 0) {
     return chunks
@@ -60,12 +60,12 @@ export function optimizeChunks(chunks: Chunk[], lowest?: VirtualOffset) {
 
   chunks.sort(function (c0, c1) {
     const dif = c0.minv.blockPosition - c1.minv.blockPosition
-    return dif !== 0 ? dif : c0.minv.dataPosition - c1.minv.dataPosition
+    return dif === 0 ? c0.minv.dataPosition - c1.minv.dataPosition : dif
   })
 
-  chunks.forEach(chunk => {
+  for (const chunk of chunks) {
     if (!lowest || chunk.maxv.compareTo(lowest) > 0) {
-      if (lastChunk === null) {
+      if (lastChunk === undefined) {
         mergedChunks.push(chunk)
         lastChunk = chunk
       } else {
@@ -79,7 +79,7 @@ export function optimizeChunks(chunks: Chunk[], lowest?: VirtualOffset) {
         }
       }
     }
-  })
+  }
 
   return mergedChunks
 }