@gmod/bbi 4.0.5 → 5.0.0

package/src/bigbed.ts

@@ -1,16 +1,16 @@
 import { Buffer } from 'buffer'
-import { Parser } from 'binary-parser'
 import { Observable, merge, firstValueFrom } from 'rxjs'
 import { map, reduce } from 'rxjs/operators'
-import AbortablePromiseCache from 'abortable-promise-cache'
+import AbortablePromiseCache from '@gmod/abortable-promise-cache'
 import QuickLRU from 'quick-lru'
 
+// locals
 import { BBI, Feature, RequestOptions } from './bbi'
 
 interface Loc {
   key: string
-  offset: bigint
-  length: bigint
+  offset: number
+  length: number
   field?: number
 }
 
@@ -46,8 +46,10 @@ export class BigBed extends BBI {
 
   /*
    * parse the bigbed extraIndex fields
-   * @param abortSignal to abort operation
-   * @return a Promise for an array of Index data structure since there can be multiple extraIndexes in a bigbed, see bedToBigBed documentation
+   *
+   *
+   * @return a Promise for an array of Index data structure since there can be
+   * multiple extraIndexes in a bigbed, see bedToBigBed documentation
    */
   private async _readIndices(opts: RequestOptions) {
     const { extHeaderOffset, isBigEndian } = await this.getHeader(opts)
@@ -57,15 +59,17 @@ export class BigBed extends BBI {
       64,
       Number(extHeaderOffset),
     )
-    const le = isBigEndian ? 'big' : 'little'
-    const ret = new Parser()
-      .endianess(le)
-      .uint16('size')
-      .uint16('count')
-      .uint64('offset')
-      .parse(data)
-
-    const { count, offset } = ret
+    const le = !isBigEndian
+
+    const b = data
+    const dataView = new DataView(b.buffer, b.byteOffset, b.length)
+    let offset = 0
+    // const _size = dataView.getUint16(offset, le)
+    offset += 2
+    const count = dataView.getUint16(offset, le)
+    offset += 2
+    const dataOffset = Number(dataView.getBigUint64(offset, le))
+    offset += 8
 
     // no extra index is defined if count==0
     if (count === 0) {
@@ -78,26 +82,30 @@ export class BigBed extends BBI {
       Buffer.alloc(len),
       0,
       len,
-      Number(offset),
+      Number(dataOffset),
     )
-    const extParser = new Parser()
-      .endianess(le)
-      .int16('type')
-      .int16('fieldcount')
-      .uint64('offset')
-      .skip(4)
-      .int16('field')
+
     const indices = [] as Index[]
 
     for (let i = 0; i < count; i += 1) {
-      indices.push(extParser.parse(buffer.subarray(i * blocklen)))
+      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)
+      offset += 2
+      const fieldcount = dataView.getInt16(offset, le)
+      offset += 2
+      const dataOffset = Number(dataView.getBigUint64(offset, le))
+      offset += 8 + 4 //4 skip
+      const field = dataView.getInt16(offset, le)
+      indices.push({ type, fieldcount, offset: Number(dataOffset), field })
     }
     return indices
   }
 
   /*
-   * perform a search in the bigbed extraIndex to find which blocks in the bigbed data to look for the
-   * actual feature data
+   * perform a search in the bigbed extraIndex to find which blocks in the
+   * bigbed data to look for the actual feature data
    *
    * @param name - the name to search for
    * @param opts - a SearchOptions argument with optional signal
@@ -112,56 +120,32 @@ export class BigBed extends BBI {
     if (indices.length === 0) {
       return []
     }
-    const locs = indices.map(async (index: any): Promise<Loc | undefined> => {
-      const { offset, field } = index
+    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,
-        Number(offset),
+        offset2,
         opts,
       )
-      const le = isBigEndian ? 'big' : 'little'
-      const p = new Parser()
-        .endianess(le)
-        .int32('magic')
-        .int32('blockSize')
-        .int32('keySize')
-        .int32('valSize')
-        .uint64('itemCount')
-
-      const { blockSize, keySize, valSize } = p.parse(data)
-      // console.log({blockSize,keySize,valSize})
-      const bpt = new Parser()
-        .endianess(le)
-        .int8('nodeType')
-        .skip(1)
-        .int16('cnt')
-        .choice({
-          tag: 'nodeType',
-          choices: {
-            0: new Parser().array('leafkeys', {
-              length: 'cnt',
-              type: new Parser()
-                .endianess(le)
-                .string('key', { length: keySize, stripNull: true })
-                .uint64('offset'),
-            }),
-            1: new Parser().array('keys', {
-              length: 'cnt',
-              type: new Parser()
-                .endianess(le)
-                .string('key', { length: keySize, stripNull: true })
-                .uint64('offset')
-                .uint32('length')
-                .uint32('reserved'),
-            }),
-          },
-        })
-
-      const bptReadNode = async (
-        nodeOffset: number,
-      ): Promise<Loc | undefined> => {
+      const le = !isBigEndian
+      const b = data
+
+      const dataView = new DataView(b.buffer, b.byteOffset, b.length)
+      let offset = 0
+      // const _magic = dataView.getInt32(offset, le)
+      offset += 4
+      const blockSize = dataView.getInt32(offset, le)
+      offset += 4
+      const keySize = dataView.getInt32(offset, le)
+      offset += 4
+      const valSize = dataView.getInt32(offset, le)
+      offset += 4
+      // const _itemCount = Number(dataView.getBigUint64(offset, le))
+      offset += 8
+
+      const bptReadNode = async (nodeOffset: number) => {
         const val = Number(nodeOffset)
         const len = 4 + blockSize * (keySize + valSize)
         const { buffer } = await this.bbi.read(
@@ -171,27 +155,62 @@ export class BigBed extends BBI {
           val,
           opts,
         )
-        const node = bpt.parse(buffer)
-        if (node.leafkeys) {
-          let lastOffset
-          for (const { key, offset } of node.leafkeys) {
+        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)
+        offset += 2
+        const keys = []
+        if (nodeType === 0) {
+          const leafkeys = []
+          for (let i = 0; i < cnt; i++) {
+            const key = b
+              .subarray(offset, offset + keySize)
+              .toString()
+              .replaceAll('\0', '')
+            offset += keySize
+            const dataOffset = Number(dataView.getBigUint64(offset, le))
+            offset += 8
+            leafkeys.push({ key, offset: dataOffset })
+          }
+
+          let lastOffset = 0
+          for (const { key, offset } of leafkeys) {
             if (name.localeCompare(key) < 0 && lastOffset) {
               return bptReadNode(lastOffset)
             }
             lastOffset = offset
           }
           return bptReadNode(lastOffset)
-        }
-        for (const n of node.keys) {
-          if (n.key === name) {
-            return { ...n, field }
+        } else if (nodeType === 1) {
+          for (let i = 0; i < cnt; i++) {
+            const key = b
+              .subarray(offset, offset + keySize)
+              .toString()
+              .replaceAll('\0', '')
+            offset += keySize
+            const dataOffset = Number(dataView.getBigUint64(offset, le))
+            offset += 8
+            const length = dataView.getUint32(offset, le)
+            offset += 4
+            const reserved = dataView.getUint32(offset, le)
+            offset += 4
+            keys.push({ key, offset: dataOffset, length, reserved })
+          }
+
+          for (const n of keys) {
+            if (n.key === name) {
+              return { ...n, field }
+            }
           }
-        }
 
-        return undefined
+          return undefined
+        }
       }
       const rootNodeOffset = 32
-      return bptReadNode(Number(offset) + rootNodeOffset)
+      return bptReadNode(offset2 + rootNodeOffset)
     })
     return filterUndef(await Promise.all(locs))
   }

package/src/bigint-polyfill/polyfill.ts

@@ -1,4 +1,4 @@
-import { getBigInt64, getBigUint64, setBigInt64, setBigUint64 } from './pure'
+import { getBigInt64, getBigUint64 } from './pure'
 
 if (!('getBigInt64' in DataView)) {
   DataView.prototype.getBigInt64 = function (byteOffset, littleEndian) {
@@ -11,15 +11,3 @@ if (!('getBigUint64' in DataView)) {
     return getBigUint64(this, byteOffset, littleEndian)
   }
 }
-
-if (!('setBigInt64' in DataView)) {
-  DataView.prototype.setBigInt64 = function (byteOffset, value, littleEndian) {
-    setBigInt64(this, byteOffset, value, littleEndian)
-  }
-}
-
-if (!('setBigUint64' in DataView)) {
-  DataView.prototype.setBigUint64 = function (byteOffset, value, littleEndian) {
-    setBigUint64(this, byteOffset, value, littleEndian)
-  }
-}

package/src/bigint-polyfill/pure.ts

@@ -40,39 +40,3 @@ export function getBigUint64(
     BigInt(a * littleEndianMask + b * bigEndianMask)
   )
 }
-
-export function setBigInt64(
-  dataView: DataView,
-  byteOffset: number,
-  value: bigint,
-  littleEndian: boolean | undefined,
-) {
-  const hi = Number(value >> BigInt32)
-  const lo = Number(value & BigInt(0xffffffff))
-
-  if (littleEndian) {
-    dataView.setInt32(byteOffset + 4, hi, littleEndian)
-    dataView.setUint32(byteOffset, lo, littleEndian)
-  } else {
-    dataView.setInt32(byteOffset, hi, littleEndian)
-    dataView.setUint32(byteOffset + 4, lo, littleEndian)
-  }
-}
-
-export function setBigUint64(
-  dataView: DataView,
-  byteOffset: number,
-  value: bigint,
-  littleEndian: boolean | undefined,
-) {
-  const hi = Number(value >> BigInt32)
-  const lo = Number(value & BigInt(0xffffffff))
-
-  if (littleEndian) {
-    dataView.setUint32(byteOffset + 4, hi, littleEndian)
-    dataView.setUint32(byteOffset, lo, littleEndian)
-  } else {
-    dataView.setUint32(byteOffset, hi, littleEndian)
-    dataView.setUint32(byteOffset + 4, lo, littleEndian)
-  }
-}

package/src/bigwig.ts

@@ -11,24 +11,18 @@ export class BigWig extends BBI {
    * or scale used to infer the zoomLevel to use
    */
   protected async getView(scale: number, opts: RequestOptions) {
-    const { zoomLevels, refsByName, fileSize, isBigEndian, uncompressBufSize } =
+    const { zoomLevels, refsByName, isBigEndian, uncompressBufSize } =
       await this.getHeader(opts)
     const basesPerPx = 1 / scale
-    let maxLevel = zoomLevels.length
-    if (!fileSize) {
-      // if we don't know the file size, we can't fetch the highest zoom level :-(
-      maxLevel -= 1
-    }
+    const maxLevel = zoomLevels.length - 1
 
     for (let i = maxLevel; i >= 0; i -= 1) {
       const zh = zoomLevels[i]
       if (zh && zh.reductionLevel <= 2 * basesPerPx) {
-        const indexOffset = Number(zh.indexOffset)
-
         return new BlockView(
           this.bbi,
           refsByName,
-          indexOffset,
+          zh.indexOffset,
           isBigEndian,
           uncompressBufSize > 0,
           'summary',