@jbrowse/core 3.6.5 → 3.7.0

package/util/flatbush/index.js

@@ -0,0 +1,362 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const flatqueue_1 = __importDefault(require("../flatqueue"));
+const ARRAY_TYPES = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+];
+const VERSION = 3;
+class Flatbush {
+    static from(data, byteOffset = 0) {
+        if (byteOffset % 8 !== 0) {
+            throw new Error('byteOffset must be 8-byte aligned.');
+        }
+        if ((data === null || data === void 0 ? void 0 : data.byteLength) === undefined || data.buffer) {
+            throw new Error('Data must be an instance of ArrayBuffer or SharedArrayBuffer.');
+        }
+        const [magic, versionAndType] = new Uint8Array(data, byteOffset + 0, 2);
+        if (magic !== 0xfb) {
+            throw new Error('Data does not appear to be in a Flatbush format.');
+        }
+        const version = versionAndType >> 4;
+        if (version !== VERSION) {
+            throw new Error(`Got v${version} data when expected v${VERSION}.`);
+        }
+        const ArrayType = ARRAY_TYPES[versionAndType & 0x0f];
+        if (!ArrayType) {
+            throw new Error('Unrecognized array type.');
+        }
+        const [nodeSize] = new Uint16Array(data, byteOffset + 2, 1);
+        const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
+        return new Flatbush(numItems, nodeSize, ArrayType, undefined, data, byteOffset);
+    }
+    constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
+        if (numItems === undefined) {
+            throw new Error('Missing required argument: numItems.');
+        }
+        if (isNaN(numItems) || numItems <= 0) {
+            throw new Error(`Unexpected numItems value: ${numItems}.`);
+        }
+        this.numItems = +numItems;
+        this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+        this.byteOffset = byteOffset;
+        let n = numItems;
+        let numNodes = n;
+        this._levelBounds = [n * 4];
+        do {
+            n = Math.ceil(n / this.nodeSize);
+            numNodes += n;
+            this._levelBounds.push(numNodes * 4);
+        } while (n !== 1);
+        this.ArrayType = ArrayType;
+        this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
+        const arrayTypeIndex = ARRAY_TYPES.indexOf(ArrayType);
+        const nodesByteSize = numNodes * 4 * ArrayType.BYTES_PER_ELEMENT;
+        if (arrayTypeIndex === -1) {
+            throw new Error(`Unexpected typed array class: ${ArrayType}.`);
+        }
+        if (data) {
+            this.data = data;
+            this._boxes = new ArrayType(data, byteOffset + 8, numNodes * 4);
+            this._indices = new this.IndexArrayType(data, byteOffset + 8 + nodesByteSize, numNodes);
+            this._pos = numNodes * 4;
+            this.minX = this._boxes[this._pos - 4];
+            this.minY = this._boxes[this._pos - 3];
+            this.maxX = this._boxes[this._pos - 2];
+            this.maxY = this._boxes[this._pos - 1];
+        }
+        else {
+            const data = (this.data = new ArrayBufferType(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT));
+            this._boxes = new ArrayType(data, 8, numNodes * 4);
+            this._indices = new this.IndexArrayType(data, 8 + nodesByteSize, numNodes);
+            this._pos = 0;
+            this.minX = Infinity;
+            this.minY = Infinity;
+            this.maxX = -Infinity;
+            this.maxY = -Infinity;
+            new Uint8Array(data, 0, 2).set([0xfb, (VERSION << 4) + arrayTypeIndex]);
+            new Uint16Array(data, 2, 1)[0] = nodeSize;
+            new Uint32Array(data, 4, 1)[0] = numItems;
+        }
+        this._queue = new flatqueue_1.default();
+    }
+    add(minX, minY, maxX = minX, maxY = minY) {
+        const index = this._pos >> 2;
+        const boxes = this._boxes;
+        this._indices[index] = index;
+        boxes[this._pos++] = minX;
+        boxes[this._pos++] = minY;
+        boxes[this._pos++] = maxX;
+        boxes[this._pos++] = maxY;
+        if (minX < this.minX) {
+            this.minX = minX;
+        }
+        if (minY < this.minY) {
+            this.minY = minY;
+        }
+        if (maxX > this.maxX) {
+            this.maxX = maxX;
+        }
+        if (maxY > this.maxY) {
+            this.maxY = maxY;
+        }
+        return index;
+    }
+    finish() {
+        if (this._pos >> 2 !== this.numItems) {
+            throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
+        }
+        const boxes = this._boxes;
+        if (this.numItems <= this.nodeSize) {
+            boxes[this._pos++] = this.minX;
+            boxes[this._pos++] = this.minY;
+            boxes[this._pos++] = this.maxX;
+            boxes[this._pos++] = this.maxY;
+            return;
+        }
+        const width = this.maxX - this.minX || 1;
+        const height = this.maxY - this.minY || 1;
+        const hilbertValues = new Uint32Array(this.numItems);
+        const hilbertMax = (1 << 16) - 1;
+        for (let i = 0, pos = 0; i < this.numItems; i++) {
+            const minX = boxes[pos++];
+            const minY = boxes[pos++];
+            const maxX = boxes[pos++];
+            const maxY = boxes[pos++];
+            const x = Math.floor((hilbertMax * ((minX + maxX) / 2 - this.minX)) / width);
+            const y = Math.floor((hilbertMax * ((minY + maxY) / 2 - this.minY)) / height);
+            hilbertValues[i] = hilbert(x, y);
+        }
+        sort(hilbertValues, boxes, this._indices, 0, this.numItems - 1, this.nodeSize);
+        for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
+            const end = this._levelBounds[i];
+            while (pos < end) {
+                const nodeIndex = pos;
+                let nodeMinX = boxes[pos++];
+                let nodeMinY = boxes[pos++];
+                let nodeMaxX = boxes[pos++];
+                let nodeMaxY = boxes[pos++];
+                for (let j = 1; j < this.nodeSize && pos < end; j++) {
+                    nodeMinX = Math.min(nodeMinX, boxes[pos++]);
+                    nodeMinY = Math.min(nodeMinY, boxes[pos++]);
+                    nodeMaxX = Math.max(nodeMaxX, boxes[pos++]);
+                    nodeMaxY = Math.max(nodeMaxY, boxes[pos++]);
+                }
+                this._indices[this._pos >> 2] = nodeIndex;
+                boxes[this._pos++] = nodeMinX;
+                boxes[this._pos++] = nodeMinY;
+                boxes[this._pos++] = nodeMaxX;
+                boxes[this._pos++] = nodeMaxY;
+            }
+        }
+    }
+    search(minX, minY, maxX, maxY, filterFn) {
+        if (this._pos !== this._boxes.length) {
+            throw new Error('Data not yet indexed - call index.finish().');
+        }
+        let nodeIndex = this._boxes.length - 4;
+        const queue = [];
+        const results = [];
+        while (nodeIndex !== undefined) {
+            const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
+            for (let pos = nodeIndex; pos < end; pos += 4) {
+                const x0 = this._boxes[pos];
+                if (maxX < x0) {
+                    continue;
+                }
+                const y0 = this._boxes[pos + 1];
+                if (maxY < y0) {
+                    continue;
+                }
+                const x1 = this._boxes[pos + 2];
+                if (minX > x1) {
+                    continue;
+                }
+                const y1 = this._boxes[pos + 3];
+                if (minY > y1) {
+                    continue;
+                }
+                const index = this._indices[pos >> 2] | 0;
+                if (nodeIndex >= this.numItems * 4) {
+                    queue.push(index);
+                }
+                else if (filterFn === undefined || filterFn(index, x0, y0, x1, y1)) {
+                    results.push(index);
+                }
+            }
+            nodeIndex = queue.pop();
+        }
+        return results;
+    }
+    neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
+        if (this._pos !== this._boxes.length) {
+            throw new Error('Data not yet indexed - call index.finish().');
+        }
+        let nodeIndex = this._boxes.length - 4;
+        const q = this._queue;
+        const results = [];
+        const maxDistSquared = maxDistance * maxDistance;
+        outer: while (nodeIndex !== undefined) {
+            const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
+            for (let pos = nodeIndex; pos < end; pos += 4) {
+                const index = this._indices[pos >> 2] | 0;
+                const minX = this._boxes[pos];
+                const minY = this._boxes[pos + 1];
+                const maxX = this._boxes[pos + 2];
+                const maxY = this._boxes[pos + 3];
+                const dx = x < minX ? minX - x : x > maxX ? x - maxX : 0;
+                const dy = y < minY ? minY - y : y > maxY ? y - maxY : 0;
+                const dist = dx * dx + dy * dy;
+                if (dist > maxDistSquared) {
+                    continue;
+                }
+                if (nodeIndex >= this.numItems * 4) {
+                    q.push(index << 1, dist);
+                }
+                else if (filterFn === undefined || filterFn(index)) {
+                    q.push((index << 1) + 1, dist);
+                }
+            }
+            while (q.length && q.peek() & 1) {
+                const dist = q.peekValue();
+                if (dist > maxDistSquared) {
+                    break outer;
+                }
+                results.push(q.pop() >> 1);
+                if (results.length === maxResults) {
+                    break outer;
+                }
+            }
+            nodeIndex = q.length ? q.pop() >> 1 : undefined;
+        }
+        q.clear();
+        return results;
+    }
+}
+exports.default = Flatbush;
+function upperBound(value, arr) {
+    let i = 0;
+    let j = arr.length - 1;
+    while (i < j) {
+        const m = (i + j) >> 1;
+        if (arr[m] > value) {
+            j = m;
+        }
+        else {
+            i = m + 1;
+        }
+    }
+    return arr[i];
+}
+function sort(values, boxes, indices, left, right, nodeSize) {
+    if (Math.floor(left / nodeSize) >= Math.floor(right / nodeSize)) {
+        return;
+    }
+    const start = values[left];
+    const mid = values[(left + right) >> 1];
+    const end = values[right];
+    let pivot = end;
+    const x = Math.max(start, mid);
+    if (end > x) {
+        pivot = x;
+    }
+    else if (x === start) {
+        pivot = Math.max(mid, end);
+    }
+    else if (x === mid) {
+        pivot = Math.max(start, end);
+    }
+    let i = left - 1;
+    let j = right + 1;
+    while (true) {
+        do {
+            i++;
+        } while (values[i] < pivot);
+        do {
+            j--;
+        } while (values[j] > pivot);
+        if (i >= j) {
+            break;
+        }
+        swap(values, boxes, indices, i, j);
+    }
+    sort(values, boxes, indices, left, j, nodeSize);
+    sort(values, boxes, indices, j + 1, right, nodeSize);
+}
+function swap(values, boxes, indices, i, j) {
+    const temp = values[i];
+    values[i] = values[j];
+    values[j] = temp;
+    const k = 4 * i;
+    const m = 4 * j;
+    const a = boxes[k];
+    const b = boxes[k + 1];
+    const c = boxes[k + 2];
+    const d = boxes[k + 3];
+    boxes[k] = boxes[m];
+    boxes[k + 1] = boxes[m + 1];
+    boxes[k + 2] = boxes[m + 2];
+    boxes[k + 3] = boxes[m + 3];
+    boxes[m] = a;
+    boxes[m + 1] = b;
+    boxes[m + 2] = c;
+    boxes[m + 3] = d;
+    const e = indices[i];
+    indices[i] = indices[j];
+    indices[j] = e;
+}
+function hilbert(x, y) {
+    let a = x ^ y;
+    let b = 0xffff ^ a;
+    let c = 0xffff ^ (x | y);
+    let d = x & (y ^ 0xffff);
+    let A = a | (b >> 1);
+    let B = (a >> 1) ^ a;
+    let C = (c >> 1) ^ (b & (d >> 1)) ^ c;
+    let D = (a & (c >> 1)) ^ (d >> 1) ^ d;
+    a = A;
+    b = B;
+    c = C;
+    d = D;
+    A = (a & (a >> 2)) ^ (b & (b >> 2));
+    B = (a & (b >> 2)) ^ (b & ((a ^ b) >> 2));
+    C ^= (a & (c >> 2)) ^ (b & (d >> 2));
+    D ^= (b & (c >> 2)) ^ ((a ^ b) & (d >> 2));
+    a = A;
+    b = B;
+    c = C;
+    d = D;
+    A = (a & (a >> 4)) ^ (b & (b >> 4));
+    B = (a & (b >> 4)) ^ (b & ((a ^ b) >> 4));
+    C ^= (a & (c >> 4)) ^ (b & (d >> 4));
+    D ^= (b & (c >> 4)) ^ ((a ^ b) & (d >> 4));
+    a = A;
+    b = B;
+    c = C;
+    d = D;
+    C ^= (a & (c >> 8)) ^ (b & (d >> 8));
+    D ^= (b & (c >> 8)) ^ ((a ^ b) & (d >> 8));
+    a = C ^ (C >> 1);
+    b = D ^ (D >> 1);
+    let i0 = x ^ y;
+    let i1 = b | (0xffff ^ (i0 | a));
+    i0 = (i0 | (i0 << 8)) & 0x00ff00ff;
+    i0 = (i0 | (i0 << 4)) & 0x0f0f0f0f;
+    i0 = (i0 | (i0 << 2)) & 0x33333333;
+    i0 = (i0 | (i0 << 1)) & 0x55555555;
+    i1 = (i1 | (i1 << 8)) & 0x00ff00ff;
+    i1 = (i1 | (i1 << 4)) & 0x0f0f0f0f;
+    i1 = (i1 | (i1 << 2)) & 0x33333333;
+    i1 = (i1 | (i1 << 1)) & 0x55555555;
+    return ((i1 << 1) | i0) >>> 0;
+}

package/util/flatqueue/index.d.ts

@@ -0,0 +1,11 @@
+export default class FlatQueue<T> {
+    ids: T[];
+    values: number[];
+    length: number;
+    clear(): void;
+    push(item: T, priority: number): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    peekValue(): number | undefined;
+    shrink(): void;
+}

package/util/flatqueue/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlatQueue {
+    constructor() {
+        this.ids = [];
+        this.values = [];
+        this.length = 0;
+    }
+    clear() {
+        this.length = 0;
+    }
+    push(item, priority) {
+        let pos = this.length++;
+        while (pos > 0) {
+            const parent = (pos - 1) >> 1;
+            const parentValue = this.values[parent];
+            if (priority >= parentValue) {
+                break;
+            }
+            this.ids[pos] = this.ids[parent];
+            this.values[pos] = parentValue;
+            pos = parent;
+        }
+        this.ids[pos] = item;
+        this.values[pos] = priority;
+    }
+    pop() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const ids = this.ids;
+        const values = this.values;
+        const top = ids[0];
+        const last = --this.length;
+        if (last > 0) {
+            const id = ids[last];
+            const value = values[last];
+            let pos = 0;
+            const halfLen = last >> 1;
+            while (pos < halfLen) {
+                const left = (pos << 1) + 1;
+                const right = left + 1;
+                const child = left + (+(right < last) & +(values[right] < values[left]));
+                if (values[child] >= value) {
+                    break;
+                }
+                ids[pos] = ids[child];
+                values[pos] = values[child];
+                pos = child;
+            }
+            ids[pos] = id;
+            values[pos] = value;
+        }
+        return top;
+    }
+    peek() {
+        return this.length > 0 ? this.ids[0] : undefined;
+    }
+    peekValue() {
+        return this.length > 0 ? this.values[0] : undefined;
+    }
+    shrink() {
+        this.ids.length = this.values.length = this.length;
+    }
+}
+exports.default = FlatQueue;

package/util/index.js

@@ -586,26 +586,26 @@ exports.complementTable = {
 };
 function revcom(str) {
     var _a;
-    let revcomped = '';
+    const revcomped = [];
     for (let i = str.length - 1; i >= 0; i--) {
-        revcomped += (_a = exports.complementTable[str[i]]) !== null && _a !== void 0 ? _a : str[i];
+        revcomped.push((_a = exports.complementTable[str[i]]) !== null && _a !== void 0 ? _a : str[i]);
     }
-    return revcomped;
+    return revcomped.join('');
 }
 function reverse(str) {
-    let reversed = '';
+    const reversed = [];
     for (let i = str.length - 1; i >= 0; i--) {
-        reversed += str[i];
+        reversed.push(str[i]);
     }
-    return reversed;
+    return reversed.join('');
 }
 function complement(str) {
     var _a;
-    let comp = '';
-    for (const element of str) {
-        comp += (_a = exports.complementTable[element]) !== null && _a !== void 0 ? _a : element;
+    const comp = [];
+    for (let i = 0, l = str.length; i < l; i++) {
+        comp.push((_a = exports.complementTable[str[i]]) !== null && _a !== void 0 ? _a : str[i]);
     }
-    return comp;
+    return comp.join('');
 }
 exports.rIC = typeof jest === 'undefined'
     ?

package/util/jexl.js

@@ -26,6 +26,7 @@ function JexlF() {
     j.addFunction('parseInt', Number.parseInt);
     j.addFunction('parseFloat', Number.parseFloat);
     j.addFunction('split', (s, char) => s.split(char));
+    j.addFunction('join', (k, ...args) => [...args].filter(f => !!f).join(k));
     j.addFunction('charAt', (s, index) => s.charAt(index));
     j.addFunction('charCodeAt', (s, index) => s.charCodeAt(index));
     j.addFunction('codePointAt', (s, pos) => s.codePointAt(pos));

package/util/layouts/PrecomputedLayout.d.ts

@@ -10,8 +10,10 @@ export default class PrecomputedLayout<T> implements BaseLayout<T> {
     private rectangles;
     private totalHeight;
     maxHeightReached: boolean;
-    private rbush;
+    private index?;
+    private indexData;
     constructor({ rectangles, totalHeight, maxHeightReached }: SerializedLayout);
+    private buildIndex;
     addRect(id: string): number;
     getRectangles(): Map<string, RectTuple>;
     getTotalHeight(): number;

package/util/layouts/PrecomputedLayout.js

@@ -3,22 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const rbush_1 = __importDefault(require("rbush"));
+const flatbush_1 = __importDefault(require("../flatbush"));
 class PrecomputedLayout {
     constructor({ rectangles, totalHeight, maxHeightReached }) {
+        this.indexData = [];
         this.rectangles = new Map(Object.entries(rectangles));
         this.totalHeight = totalHeight;
         this.maxHeightReached = maxHeightReached;
-        this.rbush = new rbush_1.default();
-        for (const [key, layout] of Object.entries(rectangles)) {
-            this.rbush.insert({
-                minX: layout[0],
-                minY: layout[1],
-                maxX: layout[2],
-                maxY: layout[3],
-                name: key,
-            });
+        this.buildIndex();
+    }
+    buildIndex() {
+        if (this.rectangles.size === 0) {
+            return;
+        }
+        this.index = new flatbush_1.default(this.rectangles.size);
+        this.indexData = [];
+        for (const [name, rect] of this.rectangles) {
+            this.index.add(rect[0], rect[1], rect[2], rect[3]);
+            this.indexData.push({ name, rect });
         }
+        this.index.finish();
     }
     addRect(id) {
         const rect = this.rectangles.get(id);
@@ -37,10 +41,15 @@ class PrecomputedLayout {
         throw new Error('Method not implemented.');
     }
     getByCoord(x, y) {
-        const rect = { minX: x, minY: y, maxX: x + 1, maxY: y + 1 };
-        return this.rbush.collides(rect)
-            ? this.rbush.search(rect)[0].name
-            : undefined;
+        var _a;
+        if (!this.index) {
+            return undefined;
+        }
+        const results = this.index.search(x, y, x + 1, y + 1);
+        if (results.length > 0) {
+            return (_a = this.indexData[results[0]]) === null || _a === void 0 ? void 0 : _a.name;
+        }
+        return undefined;
     }
     getByID(id) {
         return this.rectangles.get(id);

package/util/tracks.js

@@ -71,7 +71,7 @@ function setBlobMap(map) {
 let counter = 0;
 function storeBlobLocation(location) {
     if ('blob' in location) {
-        const blobId = `b${+Date.now()}-${counter++}`;
+        const blobId = `b${Date.now()}-${counter++}`;
         blobMap[blobId] = location.blob;
         return { name: location.blob.name, blobId, locationType: 'BlobLocation' };
     }

package/util/useFeatureSequence.d.ts

@@ -0,0 +1,19 @@
+import type { AbstractSessionModel, Feature } from '.';
+export declare function useFeatureSequence({ session, feature, upDownBp, forceLoad, assemblyName, shouldFetch, }: {
+    assemblyName: string;
+    session?: AbstractSessionModel;
+    feature: Feature;
+    upDownBp: number;
+    forceLoad: boolean;
+    shouldFetch?: boolean;
+}): {
+    sequence: {
+        seq: string;
+        upstream: string;
+        downstream: string;
+    } | {
+        error: string;
+    } | undefined;
+    loading: boolean;
+    error: unknown;
+};

package/util/useFeatureSequence.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFeatureSequence = useFeatureSequence;
+const react_1 = require("react");
+const fetchSeq_1 = require("./fetchSeq");
+const BPLIMIT = 20000000;
+function useFeatureSequence({ session, feature, upDownBp, forceLoad, assemblyName, shouldFetch = true, }) {
+    const [sequence, setSequence] = (0, react_1.useState)();
+    const [error, setError] = (0, react_1.useState)();
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const key = (0, react_1.useMemo)(() => {
+        if (!session || !shouldFetch) {
+            return null;
+        }
+        const start = feature.get('start');
+        const end = feature.get('end');
+        const refName = feature.get('refName');
+        return {
+            start,
+            end,
+            refName,
+            assemblyName,
+            upDownBp,
+            forceLoad,
+            sessionId: session.id || 'default',
+        };
+    }, [session, feature, assemblyName, upDownBp, forceLoad, shouldFetch]);
+    (0, react_1.useEffect)(() => {
+        if (!key) {
+            setSequence(undefined);
+            setError(undefined);
+            return;
+        }
+        ;
+        (async () => {
+            try {
+                setLoading(true);
+                setError(undefined);
+                const { start, end, refName, assemblyName, upDownBp, forceLoad } = key;
+                if (!forceLoad && end - start > BPLIMIT) {
+                    setSequence({
+                        error: `Genomic sequence larger than ${BPLIMIT}bp, use "force load" button to display`,
+                    });
+                    return;
+                }
+                const b = start - upDownBp;
+                const e = end + upDownBp;
+                const [seq, upstream, downstream] = await Promise.all([
+                    (0, fetchSeq_1.fetchSeq)({
+                        start,
+                        end,
+                        refName,
+                        assemblyName,
+                        session: session,
+                    }),
+                    (0, fetchSeq_1.fetchSeq)({
+                        start: Math.max(0, b),
+                        end: start,
+                        refName,
+                        assemblyName,
+                        session: session,
+                    }),
+                    (0, fetchSeq_1.fetchSeq)({
+                        start: end,
+                        end: e,
+                        refName,
+                        assemblyName,
+                        session: session,
+                    }),
+                ]);
+                setSequence({
+                    seq,
+                    upstream,
+                    downstream,
+                });
+            }
+            catch (err) {
+                setError(err);
+            }
+            finally {
+                setLoading(false);
+            }
+        })();
+    }, [key, session]);
+    return {
+        sequence,
+        loading,
+        error,
+    };
+}

package/BaseFeatureWidget/SequenceFeatureDetails/hooks.d.ts

@@ -1,10 +0,0 @@
-import type { SimpleFeatureSerialized } from '../../util';
-import type { ErrorState, SeqState } from '../util';
-export declare function useFeatureSequence(model: {
-    view?: {
-        assemblyNames?: string[];
-    };
-} | undefined, feature: SimpleFeatureSerialized, upDownBp: number, forceLoad: boolean): {
-    sequence: SeqState | ErrorState | undefined;
-    error: unknown;
-};