loom-browser 0.0.14 → 0.0.16

package/dist/loom-worker.js

@@ -3221,7 +3221,7 @@ function groupBlocks(blocks) {
     return blockGroups;
 }
 
-const decoder$1 = new TextDecoder('utf8');
+const decoder$2 = new TextDecoder('utf8');
 const CIR_TREE_MAGIC = 0x2468ace0;
 function coordFilter(s1, e1, s2, e2) {
     return s1 < e2 && e1 >= s2;
@@ -3279,7 +3279,7 @@ function parseBigBedBlock(data, startOffset, offset, request) {
             }
         }
         const b = data.subarray(currOffset, i);
-        const rest = decoder$1.decode(b);
+        const rest = decoder$2.decode(b);
         currOffset = i + 1;
         if (!request ||
             (chromId === request.chrId &&
@@ -3805,7 +3805,7 @@ class BlockView {
 
 const BIG_WIG_MAGIC = -2003829722;
 const BIG_BED_MAGIC = -2021002517;
-const decoder = new TextDecoder('utf8');
+const decoder$1 = new TextDecoder('utf8');
 function getDataView(buffer) {
     return new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
 }
@@ -3953,7 +3953,7 @@ class BBI {
             fileType,
             version,
             autoSql: asOffset
-                ? decoder.decode(b.subarray(asOffset, b.indexOf(0, asOffset)))
+                ? decoder$1.decode(b.subarray(asOffset, b.indexOf(0, asOffset)))
                 : '',
         };
     }
@@ -3982,7 +3982,7 @@ class BBI {
                     const effectiveKeyEnd = keyEnd !== -1 && keyEnd < offset + keySize
                         ? keyEnd
                         : offset + keySize;
-                    const key = decoder.decode(b.subarray(offset, effectiveKeyEnd));
+                    const key = decoder$1.decode(b.subarray(offset, effectiveKeyEnd));
                     offset += keySize;
                     const refId = dataView.getUint32(offset, true);
                     offset += 4;
@@ -4068,7 +4068,214 @@ class BigWig extends BBI {
     }
 }
 
-new TextDecoder('utf8');
+const decoder = new TextDecoder('utf8');
+function getTabField(str, fieldIndex) {
+    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, offset, keySize) {
+    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, nodeOffset, blockSize, keySize, valSize, name, field, opts) {
+    const len = 4 + blockSize * (keySize + valSize);
+    const buffer = await bbi.read(len, nodeOffset, opts);
+    const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
+    const nodeType = dataView.getInt8(0);
+    const cnt = dataView.getInt16(2, true);
+    let offset = 4;
+    // 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;
+    }
+}
+class BigBed extends BBI {
+    readIndicesCache = new AbortablePromiseCache({
+        cache: new QuickLRU({ maxSize: 1 }),
+        fill: (args, signal) => this._readIndices({ ...args, signal }),
+    });
+    readIndices(opts = {}) {
+        const { signal, ...rest } = opts;
+        return this.readIndicesCache.get(JSON.stringify(rest), opts, signal);
+    }
+    /*
+     * retrieve unzoomed view for any scale
+     */
+    async getView(_scale, opts) {
+        return this.getUnzoomedView(opts);
+    }
+    /*
+     * parse the bigbed extraIndex fields
+     *
+     *
+     * @return a Promise for an array of Index data structure since there can be
+     * multiple extraIndexes in a bigbed, see bedToBigBed documentation
+     */
+    async _readIndices(opts) {
+        const { extHeaderOffset } = await this.getHeader(opts);
+        const b = await this.bbi.read(64, extHeaderOffset);
+        const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+        const count = dataView.getUint16(2, true);
+        const dataOffset = Number(dataView.getBigUint64(4, true));
+        // no extra index is defined if count==0
+        if (count === 0) {
+            return [];
+        }
+        const blocklen = 20;
+        const len = blocklen * count;
+        const buffer = await this.bbi.read(len, dataOffset);
+        const indices = [];
+        for (let i = 0; i < count; i += 1) {
+            const b = buffer.subarray(i * blocklen);
+            const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+            const type = dataView.getInt16(0, true);
+            const fieldcount = dataView.getInt16(2, true);
+            const dataOffset = Number(dataView.getBigUint64(4, true));
+            const field = dataView.getInt16(16, true);
+            indices.push({
+                type,
+                fieldcount,
+                offset: 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
+     *
+     * @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
+     */
+    async searchExtraIndexBlocks(name, opts = {}) {
+        const indices = await this.readIndices(opts);
+        if (indices.length === 0) {
+            return [];
+        }
+        const locs = indices.map(async (index) => {
+            const { offset: offset2, field } = index;
+            const b = await this.bbi.read(32, offset2, opts);
+            const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+            const blockSize = dataView.getInt32(4, true);
+            const keySize = dataView.getInt32(8, true);
+            const valSize = dataView.getInt32(12, true);
+            return readBPlusTreeNode(this.bbi, offset2 + 32, blockSize, keySize, valSize, name, field, opts);
+        });
+        const results = await Promise.all(locs);
+        return results.filter((l) => l !== undefined);
+    }
+    /*
+     * 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 - options object with optional AbortSignal
+     *
+     * @return array of Feature
+     */
+    async searchExtraIndex(name, opts = {}) {
+        const blocks = await this.searchExtraIndexBlocks(name, opts);
+        if (blocks.length === 0) {
+            return [];
+        }
+        const view = await this.getUnzoomedView(opts);
+        const results = await Promise.all(blocks.map(async (block) => {
+            const features = await view.readFeatures([block], opts);
+            return features.map(f => ({ ...f, field: block.field }));
+        }));
+        // field offset is adjusted by -3 to account for chrom, chromStart, chromEnd columns
+        return results.flat().filter(f => {
+            if (!f.rest) {
+                return false;
+            }
+            const fieldIndex = (f.field || 0) - 3;
+            return getTabField(f.rest, fieldIndex) === name;
+        });
+    }
+}
 
 /**
  * Google Cloud URL utilities — pure functions for detecting, parsing, and
@@ -4350,14 +4557,14 @@ class BinaryParser {
 // ─── Internal helpers ─────────────────────────────────────────────────────────
 // Cache BigWig instances by URL to reuse parsed headers and trees.
 // Auth-aware readers share the cache key (URL) — the fetchImpl is bound at creation.
-const readerCache$2 = new Map();
+const readerCache$3 = new Map();
 function getGmodReader(url, fetchImpl) {
     const resolvedUrl = normalizeGoogleURL(url);
-    let reader = readerCache$2.get(resolvedUrl);
+    let reader = readerCache$3.get(resolvedUrl);
     if (!reader) {
         const fileOpts = fetchImpl ? { fetch: fetchImpl } : undefined;
         reader = new BigWig({ filehandle: new RemoteFile(resolvedUrl, fileOpts) });
-        readerCache$2.set(resolvedUrl, reader);
+        readerCache$3.set(resolvedUrl, reader);
     }
     return reader;
 }
@@ -4478,7 +4685,7 @@ async function fetchBigWigFeatures(url, locus, options = {}) {
         // Evict the cached reader so the next fetch gets a fresh one.
         // @gmod/bbi caches the header promise; an aborted parse poisons it permanently.
         if (err instanceof Error && (err.name === 'AbortError' || ((_b = err.message) === null || _b === void 0 ? void 0 : _b.includes('aborted')))) {
-            readerCache$2.delete(url);
+            readerCache$3.delete(url);
         }
         throw err;
     }
@@ -4614,6 +4821,102 @@ class BigWigDataSource {
     }
 }
 
+/**
+ * BigBed data source — fetches BED features from BigBed binary files.
+ *
+ * Uses @gmod/bbi's BigBed class for binary parsing and range queries.
+ * Returns BedFeature[] suitable for annotation track rendering.
+ *
+ * Mirrors igv.js BWSource behavior for bigbed format:
+ * - Features are decoded from BED rest fields via decodeBed()
+ * - No zoom-level summarization (unlike BigWig)
+ * - Feature density estimation from header dataCount
+ *
+ * Layer 1 (Data + Layout): no DOM.
+ */
+// Cache BigBed instances by URL to reuse parsed headers and index trees.
+const readerCache$2 = new Map();
+function getReader$2(url, fetchImpl) {
+    const resolvedUrl = normalizeGoogleURL(url);
+    let reader = readerCache$2.get(resolvedUrl);
+    if (!reader) {
+        const fileOpts = fetchImpl ? { fetch: fetchImpl } : undefined;
+        reader = new BigBed({ filehandle: new RemoteFile(resolvedUrl, fileOpts) });
+        readerCache$2.set(resolvedUrl, reader);
+    }
+    return reader;
+}
+class BigBedDataSource {
+    constructor(url, fetchImpl) {
+        this.url = url;
+        this.fetchImpl = fetchImpl;
+        this.bb = getReader$2(url, fetchImpl);
+    }
+    /** Set a chromosome name resolver for alias resolution (e.g., "1" → "chr1"). */
+    setChromNameResolver(resolver) {
+        this._resolveChromName = resolver;
+    }
+    async fetch(locus, _bpPerPixel, signal) {
+        var _a;
+        const chr = this._resolveChromName
+            ? this._resolveChromName(locus.chr)
+            : locus.chr;
+        try {
+            const rawFeatures = await this.bb.getFeatures(chr, locus.start, locus.end, { signal });
+            const result = [];
+            for (const f of rawFeatures) {
+                const parsed = parseBigBedFeature(chr, f.start, f.end, f.rest);
+                if (parsed)
+                    result.push(parsed);
+            }
+            return result;
+        }
+        catch (err) {
+            // Evict poisoned reader on abort (same pattern as BigWig)
+            if (err instanceof Error && (err.name === 'AbortError' || ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('aborted')))) {
+                readerCache$2.delete(normalizeGoogleURL(this.url));
+            }
+            throw err;
+        }
+    }
+    /**
+     * Search for a feature by name via BigBed extra index.
+     * Returns matching features, or empty array if not found or not indexed.
+     */
+    async search(name) {
+        const header = await this.bb.getHeader();
+        const results = await this.bb.searchExtraIndex(name);
+        if (results.length === 0)
+            return [];
+        const refsByNumber = header.refsByNumber;
+        const features = [];
+        for (const r of results) {
+            const chromId = r.chromId;
+            if (chromId == null || !(refsByNumber === null || refsByNumber === void 0 ? void 0 : refsByNumber[chromId]))
+                continue;
+            const chr = refsByNumber[chromId].name;
+            const parsed = parseBigBedFeature(chr, r.start, r.end, r.rest);
+            if (parsed)
+                features.push(parsed);
+        }
+        return features;
+    }
+    dispose() {
+        readerCache$2.delete(normalizeGoogleURL(this.url));
+    }
+}
+/**
+ * Parse a BigBed feature's rest field into a BedFeature.
+ * Reconstructs BED tokens from chr/start/end + tab-delimited rest, then uses decodeBed().
+ */
+function parseBigBedFeature(chr, start, end, rest) {
+    const tokens = [chr, String(start), String(end)];
+    if (rest) {
+        tokens.push(...rest.split('\t'));
+    }
+    return decodeBed(tokens);
+}
+
 /**
  * HTTP range request reader using native fetch.
  * Replaces igvxhr + BufferedReader for BigWig file reading.
@@ -11090,6 +11393,10 @@ function createDataSource(config, fetchImplOverride) {
             const fi = fetchImplOverride !== null && fetchImplOverride !== void 0 ? fetchImplOverride : buildFetchImpl(config);
             return new BigWigDataSource(config.url, (_a = config.windowFunction) !== null && _a !== void 0 ? _a : 'mean', fi);
         }
+        case 'bigbed': {
+            const fi = fetchImplOverride !== null && fetchImplOverride !== void 0 ? fetchImplOverride : buildFetchImpl(config);
+            return new BigBedDataSource(config.url, fi);
+        }
         case 'gtx': {
             const fi = fetchImplOverride !== null && fetchImplOverride !== void 0 ? fetchImplOverride : buildFetchImpl(config);
             return new GtxDataSource(config.url, config.experimentId, (_b = config.windowFunction) !== null && _b !== void 0 ? _b : 'mean', fi);