@gmod/bbi 5.0.2 → 6.0.0

package/src/bigbed.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer'
 import { Observable, merge, firstValueFrom } from 'rxjs'
 import { map, reduce } from 'rxjs/operators'
 import AbortablePromiseCache from '@gmod/abortable-promise-cache'
@@ -52,23 +51,16 @@ export class BigBed extends BBI {
    * multiple extraIndexes in a bigbed, see bedToBigBed documentation
    */
   private async _readIndices(opts: RequestOptions) {
-    const { extHeaderOffset, isBigEndian } = await this.getHeader(opts)
-    const { buffer: data } = await this.bbi.read(
-      Buffer.alloc(64),
-      0,
-      64,
-      Number(extHeaderOffset),
-    )
-    const le = !isBigEndian
-
-    const b = data
+    const { extHeaderOffset } = await this.getHeader(opts)
+    const b = await this.bbi.read(64, Number(extHeaderOffset))
+
     const dataView = new DataView(b.buffer, b.byteOffset, b.length)
     let offset = 0
-    // const _size = dataView.getUint16(offset, le)
+    // const _size = dataView.getUint16(offset, true)
     offset += 2
-    const count = dataView.getUint16(offset, le)
+    const count = dataView.getUint16(offset, true)
     offset += 2
-    const dataOffset = Number(dataView.getBigUint64(offset, le))
+    const dataOffset = Number(dataView.getBigUint64(offset, true))
     offset += 8
 
     // no extra index is defined if count==0
@@ -78,12 +70,7 @@ export class BigBed extends BBI {
 
     const blocklen = 20
     const len = blocklen * count
-    const { buffer } = await this.bbi.read(
-      Buffer.alloc(len),
-      0,
-      len,
-      Number(dataOffset),
-    )
+    const buffer = await this.bbi.read(len, Number(dataOffset))
 
     const indices = [] as Index[]
 
@@ -91,13 +78,13 @@ export class BigBed extends BBI {
       const b = buffer.subarray(i * blocklen)
       const dataView = new DataView(b.buffer, b.byteOffset, b.length)
       let offset = 0
-      const type = dataView.getInt16(offset, le)
+      const type = dataView.getInt16(offset, true)
       offset += 2
-      const fieldcount = dataView.getInt16(offset, le)
+      const fieldcount = dataView.getInt16(offset, true)
       offset += 2
-      const dataOffset = Number(dataView.getBigUint64(offset, le))
+      const dataOffset = Number(dataView.getBigUint64(offset, true))
       offset += 8 + 4 //4 skip
-      const field = dataView.getInt16(offset, le)
+      const field = dataView.getInt16(offset, true)
       indices.push({ type, fieldcount, offset: Number(dataOffset), field })
     }
     return indices
@@ -108,72 +95,62 @@ export class BigBed extends BBI {
    * bigbed data to look for the actual feature data
    *
    * @param name - the name to search for
+   *
    * @param opts - a SearchOptions argument with optional signal
+   *
    * @return a Promise for an array of bigbed block Loc entries
    */
   private async searchExtraIndexBlocks(
     name: string,
     opts: RequestOptions = {},
   ): Promise<Loc[]> {
-    const { isBigEndian } = await this.getHeader(opts)
     const indices = await this.readIndices(opts)
     if (indices.length === 0) {
       return []
     }
+    const decoder = new TextDecoder('utf8')
     const locs = indices.map(async (index): Promise<Loc | undefined> => {
       const { offset: offset2, field } = index
-      const { buffer: data } = await this.bbi.read(
-        Buffer.alloc(32),
-        0,
-        32,
-        offset2,
-        opts,
-      )
-      const le = !isBigEndian
-      const b = data
+      const b = await this.bbi.read(32, offset2, opts)
 
       const dataView = new DataView(b.buffer, b.byteOffset, b.length)
       let offset = 0
-      // const _magic = dataView.getInt32(offset, le)
+      // const _magic = dataView.getInt32(offset, true)
       offset += 4
-      const blockSize = dataView.getInt32(offset, le)
+      const blockSize = dataView.getInt32(offset, true)
       offset += 4
-      const keySize = dataView.getInt32(offset, le)
+      const keySize = dataView.getInt32(offset, true)
       offset += 4
-      const valSize = dataView.getInt32(offset, le)
+      const valSize = dataView.getInt32(offset, true)
       offset += 4
-      // const _itemCount = Number(dataView.getBigUint64(offset, le))
+      // const _itemCount = Number(dataView.getBigUint64(offset, true))
       offset += 8
 
       const bptReadNode = async (nodeOffset: number) => {
         const val = Number(nodeOffset)
         const len = 4 + blockSize * (keySize + valSize)
-        const { buffer } = await this.bbi.read(
-          Buffer.alloc(len),
-          0,
-          len,
-          val,
-          opts,
-        )
+        const buffer = await this.bbi.read(len, val, opts)
         const b = buffer
         const dataView = new DataView(b.buffer, b.byteOffset, b.length)
         let offset = 0
         const nodeType = dataView.getInt8(offset)
         offset += 2 //skip 1
-        const cnt = dataView.getInt16(offset, le)
+        const cnt = dataView.getInt16(offset, true)
         offset += 2
         const keys = []
         if (nodeType === 0) {
           const leafkeys = []
           for (let i = 0; i < cnt; i++) {
-            const key = b
-              .subarray(offset, offset + keySize)
-              .toString()
+            const key = decoder
+              .decode(b.subarray(offset, offset + keySize))
               .replaceAll('\0', '')
             offset += keySize
-            const dataOffset = Number(dataView.getBigUint64(offset, le))
+            const dataOffset = Number(dataView.getBigUint64(offset, true))
             offset += 8
-            leafkeys.push({ key, offset: dataOffset })
+            leafkeys.push({
+              key,
+              offset: dataOffset,
+            })
           }
 
           let lastOffset = 0
@@ -186,18 +163,22 @@ export class BigBed extends BBI {
           return bptReadNode(lastOffset)
         } else if (nodeType === 1) {
           for (let i = 0; i < cnt; i++) {
-            const key = b
-              .subarray(offset, offset + keySize)
-              .toString()
+            const key = decoder
+              .decode(b.subarray(offset, offset + keySize))
               .replaceAll('\0', '')
             offset += keySize
-            const dataOffset = Number(dataView.getBigUint64(offset, le))
+            const dataOffset = Number(dataView.getBigUint64(offset, true))
             offset += 8
-            const length = dataView.getUint32(offset, le)
+            const length = dataView.getUint32(offset, true)
             offset += 4
-            const reserved = dataView.getUint32(offset, le)
+            const reserved = dataView.getUint32(offset, true)
             offset += 4
-            keys.push({ key, offset: dataOffset, length, reserved })
+            keys.push({
+              key,
+              offset: dataOffset,
+              length,
+              reserved,
+            })
           }
 
           for (const n of keys) {
@@ -221,8 +202,10 @@ export class BigBed extends BBI {
    * the BigBed specification and the -extraIndex argument to bedToBigBed
    *
    * @param name - the name to search for
-   * @param opts - a SearchOptions argument with optional signal
-   * @return a Promise for an array of Feature
+   *
+   * @param opts - options object with optional AboutSignal
+   *
+   * @return array of Feature
    */
   public async searchExtraIndex(name: string, opts: RequestOptions = {}) {
     const blocks = await this.searchExtraIndexBlocks(name, opts)

package/src/bigwig.ts

@@ -11,7 +11,7 @@ export class BigWig extends BBI {
    * or scale used to infer the zoomLevel to use
    */
   protected async getView(scale: number, opts: RequestOptions) {
-    const { zoomLevels, refsByName, isBigEndian, uncompressBufSize } =
+    const { zoomLevels, refsByName, uncompressBufSize } =
       await this.getHeader(opts)
     const basesPerPx = 1 / scale
     const maxLevel = zoomLevels.length - 1
@@ -24,7 +24,6 @@ export class BigWig extends BBI {
           this.bbi,
           refsByName,
           zh.indexOffset,
-          isBigEndian,
           uncompressBufSize > 0,
           'summary',
         )

package/src/block-view.ts

@@ -1,7 +1,6 @@
-import { Buffer } from 'buffer'
 import { Observer } from 'rxjs'
 import AbortablePromiseCache from '@gmod/abortable-promise-cache'
-import { GenericFilehandle } from 'generic-filehandle'
+import { GenericFilehandle } from 'generic-filehandle2'
 import QuickLRU from 'quick-lru'
 
 // locals
@@ -42,18 +41,15 @@ function coordFilter(s1: number, e1: number, s2: number, e2: number): boolean {
  */
 
 export class BlockView {
-  private cirTreePromise?: Promise<{ bytesRead: number; buffer: Buffer }>
+  private cirTreePromise?: Promise<Uint8Array>
 
-  private featureCache = new AbortablePromiseCache<ReadData, Buffer>({
+  private featureCache = new AbortablePromiseCache<ReadData, Uint8Array>({
     cache: new QuickLRU({ maxSize: 1000 }),
 
     fill: async (requestData, signal) => {
-      const len = requestData.length
-      const off = requestData.offset
-      const { buffer } = await this.bbi.read(Buffer.alloc(len), 0, len, off, {
+      return this.bbi.read(requestData.length, requestData.offset, {
         signal,
       })
-      return buffer
     },
   })
 
@@ -61,7 +57,6 @@ export class BlockView {
     private bbi: GenericFilehandle,
     private refsByName: any,
     private cirTreeOffset: number,
-    private isBigEndian: boolean,
     private isCompressed: boolean,
     private blockType: string,
   ) {
@@ -78,31 +73,23 @@ export class BlockView {
     opts?: Options,
   ) {
     try {
-      const { refsByName, bbi, cirTreeOffset, isBigEndian } = this
+      const { refsByName, bbi, cirTreeOffset } = this
       const chrId = refsByName[chrName]
       if (chrId === undefined) {
         observer.complete()
       }
       const request = { chrId, start, end }
       if (!this.cirTreePromise) {
-        this.cirTreePromise = bbi.read(
-          Buffer.alloc(48),
-          0,
-          48,
-          cirTreeOffset,
-          opts,
-        )
+        this.cirTreePromise = bbi.read(48, cirTreeOffset, opts)
       }
-      const { buffer } = await this.cirTreePromise
-      const cirBlockSize = isBigEndian
-        ? buffer.readUInt32BE(4)
-        : buffer.readUInt32LE(4)
+      const buffer = await this.cirTreePromise
+      const dataView = new DataView(buffer.buffer)
+      const cirBlockSize = dataView.getUint32(4, true)
       let blocksToFetch: any[] = []
       let outstanding = 0
-      const le = true
 
       const cirFobRecur2 = (
-        cirBlockData: Buffer,
+        cirBlockData: Uint8Array,
         offset2: number,
         level: number,
       ) => {
@@ -115,22 +102,22 @@ export class BlockView {
 
           const isLeaf = dataView.getUint8(offset)
           offset += 2 // 1 skip
-          const cnt = dataView.getUint16(offset, le)
+          const cnt = dataView.getUint16(offset, true)
           offset += 2
           if (isLeaf === 1) {
             const blocksToFetch2 = []
             for (let i = 0; i < cnt; i++) {
-              const startChrom = dataView.getUint32(offset, le)
+              const startChrom = dataView.getUint32(offset, true)
               offset += 4
-              const startBase = dataView.getUint32(offset, le)
+              const startBase = dataView.getUint32(offset, true)
               offset += 4
-              const endChrom = dataView.getUint32(offset, le)
+              const endChrom = dataView.getUint32(offset, true)
               offset += 4
-              const endBase = dataView.getUint32(offset, le)
+              const endBase = dataView.getUint32(offset, true)
               offset += 4
-              const blockOffset = Number(dataView.getBigUint64(offset, le))
+              const blockOffset = Number(dataView.getBigUint64(offset, true))
               offset += 8
-              const blockSize = Number(dataView.getBigUint64(offset, le))
+              const blockSize = Number(dataView.getBigUint64(offset, true))
               offset += 8
               blocksToFetch2.push({
                 startChrom,
@@ -153,15 +140,15 @@ export class BlockView {
           } else if (isLeaf === 0) {
             const recurOffsets = []
             for (let i = 0; i < cnt; i++) {
-              const startChrom = dataView.getUint32(offset, le)
+              const startChrom = dataView.getUint32(offset, true)
               offset += 4
-              const startBase = dataView.getUint32(offset, le)
+              const startBase = dataView.getUint32(offset, true)
               offset += 4
-              const endChrom = dataView.getUint32(offset, le)
+              const endChrom = dataView.getUint32(offset, true)
               offset += 4
-              const endBase = dataView.getUint32(offset, le)
+              const endBase = dataView.getUint32(offset, true)
               offset += 4
-              const blockOffset = Number(dataView.getBigUint64(offset, le))
+              const blockOffset = Number(dataView.getBigUint64(offset, true))
               offset += 8
               recurOffsets.push({
                 startChrom,
@@ -205,7 +192,7 @@ export class BlockView {
         try {
           const length = fr.max - fr.min
           const offset = fr.min
-          const resultBuffer: Buffer = await this.featureCache.get(
+          const resultBuffer = await this.featureCache.get(
             `${length}_${offset}`,
             { length, offset },
             opts?.signal,
@@ -264,7 +251,7 @@ export class BlockView {
   }
 
   private parseSummaryBlock(
-    b: Buffer,
+    b: Uint8Array,
     startOffset: number,
     request?: CoordRequest,
   ) {
@@ -314,23 +301,22 @@ export class BlockView {
   }
 
   private parseBigBedBlock(
-    data: Buffer,
+    data: Uint8Array,
     startOffset: number,
     offset: number,
     request?: CoordRequest,
   ) {
     const items = [] as Feature[]
     let currOffset = startOffset
-    const le = true
     const b = data
     const dataView = new DataView(b.buffer, b.byteOffset, b.length)
     while (currOffset < data.byteLength) {
       const c2 = currOffset
-      const chromId = dataView.getUint32(currOffset, le)
+      const chromId = dataView.getUint32(currOffset, true)
       currOffset += 4
-      const start = dataView.getInt32(currOffset, le)
+      const start = dataView.getInt32(currOffset, true)
       currOffset += 4
-      const end = dataView.getInt32(currOffset, le)
+      const end = dataView.getInt32(currOffset, true)
       currOffset += 4
       let i = currOffset
       for (; i < data.length; i++) {
@@ -358,7 +344,7 @@ export class BlockView {
   }
 
   private parseBigWigBlock(
-    buffer: Buffer,
+    buffer: Uint8Array,
     startOffset: number,
     req?: CoordRequest,
   ) {
@@ -450,32 +436,28 @@ export class BlockView {
           )
           for (const block of blockGroup.blocks) {
             checkAbortSignal(signal)
-            let blockOffset = Number(block.offset) - Number(blockGroup.offset)
-            let resultData = data
+            let resultData = data.subarray(
+              Number(block.offset) - Number(blockGroup.offset),
+            )
             if (isCompressed) {
-              resultData = unzip(data.subarray(blockOffset))
-              blockOffset = 0
+              resultData = unzip(resultData)
             }
             checkAbortSignal(signal)
 
             switch (blockType) {
               case 'summary': {
-                observer.next(
-                  this.parseSummaryBlock(resultData, blockOffset, request),
-                )
+                observer.next(this.parseSummaryBlock(resultData, 0, request))
                 break
               }
               case 'bigwig': {
-                observer.next(
-                  this.parseBigWigBlock(resultData, blockOffset, request),
-                )
+                observer.next(this.parseBigWigBlock(resultData, 0, request))
                 break
               }
               case 'bigbed': {
                 observer.next(
                   this.parseBigBedBlock(
                     resultData,
-                    blockOffset,
+                    0,
                     Number(block.offset) * (1 << 8),
                     request,
                   ),

package/src/unzip-pako.ts

@@ -1,6 +1,5 @@
-import { Buffer } from 'buffer'
 import { inflateRaw } from 'pako'
 
-export function unzip(input: Buffer) {
+export function unzip(input: Uint8Array) {
   return inflateRaw(input.subarray(2))
 }