@gmod/bbi 7.1.0 → 8.0.1

package/src/bigbed.ts

@@ -6,6 +6,9 @@ import { map, reduce } from 'rxjs/operators'
 import { BBI } from './bbi.ts'
 
 import type { Feature, RequestOptions } from './types.ts'
+import type { GenericFilehandle } from 'generic-filehandle2'
+
+const decoder = new TextDecoder('utf8')
 
 interface Loc {
   key: string
@@ -25,6 +28,133 @@ export function filterUndef<T>(ts: (T | undefined)[]): T[] {
   return ts.filter((t: T | undefined): t is T => !!t)
 }
 
+function getTabField(str: string, fieldIndex: number) {
+  if (fieldIndex < 0) {
+    return undefined
+  }
+  let start = 0
+  for (let i = 0; i < fieldIndex; i++) {
+    start = str.indexOf('\t', start)
+    if (start === -1) {
+      return undefined
+    }
+    start++
+  }
+  const end = str.indexOf('\t', start)
+  return end === -1 ? str.slice(start) : str.slice(start, end)
+}
+
+// Parses a null-terminated string key from a B+ tree node
+function parseKey(buffer: Uint8Array, offset: number, keySize: number) {
+  const keyEnd = buffer.indexOf(0, offset)
+  const effectiveKeyEnd =
+    keyEnd !== -1 && keyEnd < offset + keySize ? keyEnd : offset + keySize
+  return decoder.decode(buffer.subarray(offset, effectiveKeyEnd))
+}
+
+// Recursively traverses a B+ tree to search for a specific name in the BigBed extraIndex
+// B+ trees are balanced tree structures optimized for disk-based searches
+async function readBPlusTreeNode(
+  bbi: GenericFilehandle,
+  nodeOffset: number,
+  blockSize: number,
+  keySize: number,
+  valSize: number,
+  name: string,
+  field: number,
+  opts: RequestOptions,
+): Promise<Loc | undefined> {
+  const len = 4 + blockSize * (keySize + valSize)
+  const buffer = await bbi.read(len, nodeOffset, opts)
+  const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length)
+  let offset = 0
+  const nodeType = dataView.getInt8(offset)
+  offset += 2 // skip nodeType byte + 1 reserved byte
+  const cnt = dataView.getInt16(offset, true)
+  offset += 2
+
+  // Non-leaf node (nodeType === 0): contains keys and child node pointers for navigation
+  if (nodeType === 0) {
+    const leafkeys = []
+    for (let i = 0; i < cnt; i++) {
+      const key = parseKey(buffer, offset, keySize)
+      offset += keySize
+      const dataOffset = Number(dataView.getBigUint64(offset, true))
+      offset += 8
+      leafkeys.push({
+        key,
+        offset: dataOffset,
+      })
+    }
+
+    // Binary search to find the appropriate child node
+    let left = 0
+    let right = leafkeys.length - 1
+    let targetIndex = leafkeys.length - 1
+
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2)
+      const cmp = name.localeCompare(leafkeys[mid]!.key)
+
+      if (cmp < 0) {
+        targetIndex = mid - 1
+        right = mid - 1
+      } else {
+        left = mid + 1
+      }
+    }
+
+    const childOffset =
+      targetIndex >= 0 ? leafkeys[targetIndex]!.offset : leafkeys[0]!.offset
+    return readBPlusTreeNode(
+      bbi,
+      childOffset,
+      blockSize,
+      keySize,
+      valSize,
+      name,
+      field,
+      opts,
+    )
+  } else if (nodeType === 1) {
+    // Leaf node (nodeType === 1): contains actual key-value data
+    const keys = []
+    for (let i = 0; i < cnt; i++) {
+      const key = parseKey(buffer, offset, keySize)
+      offset += keySize
+      const dataOffset = Number(dataView.getBigUint64(offset, true))
+      offset += 8
+      const length = dataView.getUint32(offset, true)
+      offset += 4
+      offset += 4 // skip reserved
+      keys.push({
+        key,
+        offset: dataOffset,
+        length,
+      })
+    }
+
+    // Binary search for exact key match in sorted leaf node
+    let left = 0
+    let right = keys.length - 1
+
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2)
+      const cmp = name.localeCompare(keys[mid]!.key)
+
+      if (cmp === 0) {
+        return { ...keys[mid]!, field }
+      } else if (cmp < 0) {
+        right = mid - 1
+      } else {
+        left = mid + 1
+      }
+    }
+
+    return undefined
+  }
+}
+
 export class BigBed extends BBI {
   public readIndicesCache = new AbortablePromiseCache<RequestOptions, Index[]>({
     cache: new QuickLRU({ maxSize: 1 }),
@@ -73,7 +203,7 @@ export class BigBed extends BBI {
     const len = blocklen * count
     const buffer = await this.bbi.read(len, dataOffset)
 
-    const indices = [] as Index[]
+    const indices: Index[] = []
 
     for (let i = 0; i < count; i += 1) {
       const b = buffer.subarray(i * blocklen)
@@ -84,7 +214,7 @@ export class BigBed extends BBI {
       const fieldcount = dataView.getInt16(offset, true)
       offset += 2
       const dataOffset = Number(dataView.getBigUint64(offset, true))
-      offset += 8 + 4 //4 skip
+      offset += 8 + 4 // skip 8-byte offset + 4 reserved bytes
       const field = dataView.getInt16(offset, true)
       indices.push({
         type,
@@ -114,7 +244,6 @@ export class BigBed extends BBI {
     if (indices.length === 0) {
       return []
     }
-    const decoder = new TextDecoder('utf8')
     const locs = indices.map(async index => {
       const { offset: offset2, field } = index
       const b = await this.bbi.read(32, offset2, opts)
@@ -132,74 +261,16 @@ export class BigBed extends BBI {
       // const _itemCount = Number(dataView.getBigUint64(offset, true))
       offset += 8
 
-      const bptReadNode = async (nodeOffset: number) => {
-        const val = nodeOffset
-        const len = 4 + blockSize * (keySize + valSize)
-        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, true)
-        offset += 2
-        const keys = []
-        if (nodeType === 0) {
-          const leafkeys = []
-          for (let i = 0; i < cnt; i++) {
-            const key = decoder
-              .decode(b.subarray(offset, offset + keySize))
-              .replaceAll('\0', '')
-            offset += keySize
-            const dataOffset = Number(dataView.getBigUint64(offset, true))
-            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)
-        } else if (nodeType === 1) {
-          for (let i = 0; i < cnt; i++) {
-            const key = decoder
-              .decode(b.subarray(offset, offset + keySize))
-              .replaceAll('\0', '')
-            offset += keySize
-            const dataOffset = Number(dataView.getBigUint64(offset, true))
-            offset += 8
-            const length = dataView.getUint32(offset, true)
-            offset += 4
-            const reserved = dataView.getUint32(offset, true)
-            offset += 4
-            keys.push({
-              key,
-              offset: dataOffset,
-              length,
-              reserved,
-            })
-          }
-
-          for (const n of keys) {
-            if (n.key === name) {
-              return {
-                ...n,
-                field,
-              }
-            }
-          }
-
-          return undefined
-        }
-      }
-      return bptReadNode(offset2 + 32)
+      return readBPlusTreeNode(
+        this.bbi,
+        offset2 + 32,
+        blockSize,
+        keySize,
+        valSize,
+        name,
+        field,
+        opts,
+      )
     })
     return filterUndef(await Promise.all(locs))
   }
@@ -211,7 +282,7 @@ export class BigBed extends BBI {
    *
    * @param name - the name to search for
    *
-   * @param opts - options object with optional AboutSignal
+   * @param opts - options object with optional AbortSignal
    *
    * @return array of Feature
    */
@@ -227,16 +298,22 @@ export class BigBed extends BBI {
           observer.error(e)
         })
       }).pipe(
-        reduce((acc, curr) => acc.concat(curr)),
-        map(x => {
-          for (const element of x) {
-            element.field = block.field
-          }
-          return x
-        }),
+        reduce((acc, curr) => {
+          acc.push(...curr)
+          return acc
+        }, [] as Feature[]),
+        map(features => features.map(f => ({ ...f, field: block.field }))),
       )
     })
     const ret = await firstValueFrom(merge(...res))
-    return ret.filter(f => f.rest?.split('\t')[(f.field || 0) - 3] === name)
+    // Filter to features where the indexed field matches the search name
+    // field offset is adjusted by -3 to account for chrom, chromStart, chromEnd columns
+    return ret.filter(f => {
+      if (!f.rest) {
+        return false
+      }
+      const fieldIndex = (f.field || 0) - 3
+      return getTabField(f.rest, fieldIndex) === name
+    })
   }
 }

package/src/bigwig.ts

@@ -20,13 +20,12 @@ export class BigWig extends BBI {
 
     for (let i = maxLevel; i >= 0; i -= 1) {
       const zh = zoomLevels[i]
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (zh && zh.reductionLevel <= 2 * basesPerPx) {
         return new BlockView(
           this.bbi,
           refsByName,
           zh.indexOffset,
-          uncompressBufSize > 0,
+          uncompressBufSize,
           'summary',
         )
       }