@gmod/bbi 4.0.3 → 4.0.5

package/src/bigbed.ts

@@ -174,18 +174,17 @@ export class BigBed extends BBI {
         const node = bpt.parse(buffer)
         if (node.leafkeys) {
           let lastOffset
-          for (let i = 0; i < node.leafkeys.length; i += 1) {
-            const { key } = node.leafkeys[i]
+          for (const { key, offset } of node.leafkeys) {
             if (name.localeCompare(key) < 0 && lastOffset) {
               return bptReadNode(lastOffset)
             }
-            lastOffset = node.leafkeys[i].offset
+            lastOffset = offset
           }
           return bptReadNode(lastOffset)
         }
-        for (let i = 0; i < node.keys.length; i += 1) {
-          if (node.keys[i].key === name) {
-            return { ...node.keys[i], field }
+        for (const n of node.keys) {
+          if (n.key === name) {
+            return { ...n, field }
           }
         }
 
@@ -198,8 +197,9 @@ export class BigBed extends BBI {
   }
 
   /*
-   * retrieve the features from the bigbed data that were found through the lookup of the extraIndex
-   * note that there can be multiple extraIndex, see the BigBed specification and the -extraIndex argument to bedToBigBed
+   * retrieve the features from the bigbed data that were found through the
+   * lookup of the extraIndex note that there can be multiple extraIndex, see
+   * the BigBed specification and the -extraIndex argument to bedToBigBed
    *
    * @param name - the name to search for
    * @param opts - a SearchOptions argument with optional signal
@@ -213,7 +213,7 @@ export class BigBed extends BBI {
     const view = await this.getUnzoomedView(opts)
     const res = blocks.map(block => {
       return new Observable<Feature[]>(observer => {
-        view.readFeatures(observer, [block], opts)
+        view.readFeatures(observer, [block], opts).catch(e => observer.error(e))
       }).pipe(
         reduce((acc, curr) => acc.concat(curr)),
         map(x => {

package/src/bigwig.ts

@@ -6,7 +6,9 @@ export class BigWig extends BBI {
    * Retrieves a BlockView of a specific zoomLevel
    *
    * @param scale - number
-   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+   *
+   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair)
+   * or scale used to infer the zoomLevel to use
    */
   protected async getView(scale: number, opts: RequestOptions) {
     const { zoomLevels, refsByName, fileSize, isBigEndian, uncompressBufSize } =

package/src/block-view.ts

@@ -235,7 +235,7 @@ export class BlockView {
             blocksToFetch = blocksToFetch.concat(
               p.blocksToFetch
                 .filter(f => filterFeats(f))
-                .map((l: { blockOffset: bigint; blockSize: bigint }) => ({
+                .map(l => ({
                   offset: l.blockOffset,
                   length: l.blockSize,
                 })),
@@ -268,8 +268,8 @@ export class BlockView {
         level: number,
       ) => {
         try {
-          const length = fr.max() - fr.min()
-          const offset = fr.min()
+          const length = fr.max - fr.min
+          const offset = fr.min
           const resultBuffer: Buffer = await this.featureCache.get(
             `${length}_${offset}`,
             { length, offset },
@@ -280,7 +280,10 @@ export class BlockView {
               cirFobRecur2(resultBuffer, element - offset, level)
               outstanding -= 1
               if (outstanding === 0) {
-                this.readFeatures(observer, blocksToFetch, { ...opts, request })
+                this.readFeatures(observer, blocksToFetch, {
+                  ...opts,
+                  request,
+                }).catch(e => observer.error(e))
               }
             }
           }
@@ -294,11 +297,16 @@ export class BlockView {
 
           // Upper bound on size, based on a completely full leaf node.
           const maxCirBlockSpan = 4 + Number(cirBlockSize) * 32
-          let spans = new Range(offset[0], offset[0] + maxCirBlockSpan)
+          let spans = new Range([
+            { min: offset[0], max: offset[0] + maxCirBlockSpan },
+          ])
           for (let i = 1; i < offset.length; i += 1) {
-            const blockSpan = new Range(offset[i], offset[i] + maxCirBlockSpan)
+            const blockSpan = new Range([
+              { min: offset[i], max: offset[i] + maxCirBlockSpan },
+            ])
             spans = spans.union(blockSpan)
           }
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
           spans.getRanges().map(fr => cirFobStartFetch(offset, fr, level))
         } catch (e) {
           observer.error(e)

package/src/range.ts

@@ -1,32 +1,29 @@
-/* eslint prefer-rest-params:0, no-nested-ternary:0 */
-
 /**
  * Adapted from a combination of Range and _Compound in the
  * Dalliance Genome Explorer, (c) Thomas Down 2006-2010.
  */
+
+export interface IRange {
+  min: number
+  max: number
+}
 export default class Range {
-  public ranges: any
+  public ranges: IRange[]
 
-  public constructor(arg1: any, arg2?: any) {
-    this.ranges =
-      arguments.length === 2
-        ? [{ min: arg1, max: arg2 }]
-        : 0 in arg1
-          ? Object.assign({}, arg1)
-          : [arg1]
+  public constructor(arg1: IRange[]) {
+    this.ranges = arg1
   }
 
-  public min(): number {
+  get min() {
     return this.ranges[0].min
   }
 
-  public max(): number {
+  get max() {
     return this.ranges[this.ranges.length - 1].max
   }
 
-  public contains(pos: number): boolean {
-    for (let s = 0; s < this.ranges.length; s += 1) {
-      const r = this.ranges[s]
+  public contains(pos: number) {
+    for (const r of this.ranges) {
       if (r.min <= pos && r.max >= pos) {
         return true
       }
@@ -38,104 +35,41 @@ export default class Range {
     return this.ranges.length > 1
   }
 
-  public getRanges(): Range[] {
-    return this.ranges.map((r: Range) => new Range(r.min, r.max))
+  public getRanges() {
+    return this.ranges.map(r => new Range([{ min: r.min, max: r.max }]))
   }
 
   public toString(): string {
-    return this.ranges.map((r: Range) => `[${r.min}-${r.max}]`).join(',')
+    return this.ranges.map(r => `[${r.min}-${r.max}]`).join(',')
   }
 
-  public union(s1: Range): Range {
-    const ranges = this.getRanges().concat(s1.getRanges()).sort(this.rangeOrder)
-    const oranges = []
+  public union(s1: Range) {
+    const ranges = [...this.getRanges(), ...s1.getRanges()].sort((a, b) => {
+      if (a.min < b.min) {
+        return -1
+      } else if (a.min > b.min) {
+        return 1
+      } else if (a.max < b.max) {
+        return -1
+      } else if (b.max > a.max) {
+        return 1
+      } else {
+        return 0
+      }
+    })
+    const oranges = [] as Range[]
     let current = ranges[0]
 
-    for (let i = 1; i < ranges.length; i += 1) {
-      const nxt = ranges[i]
-      if (nxt.min() > current.max() + 1) {
+    for (const nxt of ranges) {
+      if (nxt.min > current.max + 1) {
         oranges.push(current)
         current = nxt
-      } else if (nxt.max() > current.max()) {
-        current = new Range(current.min(), nxt.max())
+      } else if (nxt.max > current.max) {
+        current = new Range([{ min: current.min, max: nxt.max }])
       }
     }
     oranges.push(current)
 
-    if (oranges.length === 1) {
-      return oranges[0]
-    }
-    return new Range(oranges)
-  }
-
-  public intersection(arg: Range): Range {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias,unicorn/no-this-assignment
-    let s0 = this
-    let s1 = arg
-    const r0 = this.ranges()
-    const r1 = s1.ranges()
-    const l0 = r0.length
-
-    const l1 = r1.length
-    let i0 = 0
-
-    let i1 = 0
-    const or = []
-
-    while (i0 < l0 && i1 < l1) {
-      s0 = r0[i0]
-      s1 = r1[i1]
-      const lapMin = Math.max(s0.min(), s1.min())
-      const lapMax = Math.min(s0.max(), s1.max())
-      if (lapMax >= lapMin) {
-        or.push(new Range(lapMin, lapMax))
-      }
-      if (s0.max() > s1.max()) {
-        i1 += 1
-      } else {
-        i0 += 1
-      }
-    }
-
-    if (or.length === 0) {
-      throw new Error('found range of length 0')
-    }
-    if (or.length === 1) {
-      return or[0]
-    }
-    return new Range(or)
-  }
-
-  public coverage(): number {
-    let tot = 0
-    const rl = this.ranges()
-    for (const r of rl) {
-      tot += r.max() - r.min() + 1
-    }
-    return tot
-  }
-
-  public rangeOrder(tmpa: Range, tmpb: Range): number {
-    let a = tmpa
-    let b = tmpb
-    if (arguments.length < 2) {
-      b = a
-      // eslint-disable-next-line @typescript-eslint/no-this-alias,unicorn/no-this-assignment
-      a = this
-    }
-
-    if (a.min() < b.min()) {
-      return -1
-    }
-    if (a.min() > b.min()) {
-      return 1
-    }
-    if (a.max() < b.max()) {
-      return -1
-    }
-    if (b.max() > a.max()) {
-      return 1
-    }
-    return 0
+    return oranges.length === 1 ? oranges[0] : new Range(oranges)
   }
 }