@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/util/Base1DViewModel.js

@@ -1,119 +1,220 @@
-import { cast, types } from '@jbrowse/mobx-state-tree';
-import { bpToPx, moveTo, pxToBp } from "./Base1DUtils.js";
-import calculateDynamicBlocks from "./calculateDynamicBlocks.js";
-import calculateStaticBlocks from "./calculateStaticBlocks.js";
-import { clamp, sum } from "./index.js";
-import { ElementId } from "./types/mst.js";
-function x() { }
+import { types } from '@jbrowse/mobx-state-tree';
+import { layoutBpToPx, moveTo, pxToBp } from './Base1DUtils.js';
+import calculateDynamicBlocks from './calculateDynamicBlocks.js';
+import calculateStaticBlocks from './calculateStaticBlocks.js';
+import { clamp } from './numericUtils.js';
+import { ElementId } from './types/mst.js';
+/**
+ * #stateModel Base1DView
+ * #category general
+ * used in non-lgv view representations of a 1d view e.g. the two axes of the
+ * dotplot use this. categorized General rather than View because it is not a
+ * pluggable view type, which the name-suffix heuristic would otherwise assume
+ */
 const Base1DView = types
     .model('Base1DView', {
+    /**
+     * #property
+     */
     id: ElementId,
+    /**
+     * #property
+     */
     displayedRegions: types.optional(types.frozen(), []),
+    /**
+     * #property
+     */
     bpPerPx: 0,
+    /**
+     * #property
+     */
     offsetPx: 0,
-    interRegionPaddingWidth: types.optional(types.number, 0),
-    minimumBlockWidth: types.optional(types.number, 0),
+    /**
+     * #property
+     */
+    minimumBlockWidth: types.stripDefault(types.number, 0),
 })
     .volatile(() => ({
-    features: undefined,
     volatileWidth: 0,
 }))
     .actions(self => ({
+    /**
+     * #action
+     */
     setDisplayedRegions(regions) {
-        self.displayedRegions = cast(regions);
+        self.displayedRegions = regions;
     },
+    /**
+     * #action
+     */
     setBpPerPx(val) {
         self.bpPerPx = val;
     },
+    /**
+     * #action
+     */
     setVolatileWidth(width) {
         self.volatileWidth = width;
     },
 }))
     .views(self => ({
+    /**
+     * #getter
+     */
     get width() {
         return self.volatileWidth;
     },
+    /**
+     * #getter
+     * zoom-in floor; overridden by extensions (e.g. the dotplot axes)
+     */
+    get minBpPerPx() {
+        return 0;
+    },
+    /**
+     * #getter
+     * zoom-out ceiling; overridden by extensions (e.g. the dotplot axes)
+     */
+    get maxBpPerPx() {
+        return Number.POSITIVE_INFINITY;
+    },
+    /**
+     * #getter
+     */
     get assemblyNames() {
         return [...new Set(self.displayedRegions.map(r => r.assemblyName))];
     },
+    /**
+     * #getter
+     */
     get displayedRegionsTotalPx() {
-        return this.totalBp / self.bpPerPx;
-    },
+        // bpPerPx defaults to 0 (the not-yet-measured sentinel) until setWidth
+        // runs, so guard the division — otherwise offset/scroll getters that
+        // consume this (e.g. dotplot's centeredOffset/minOffset) go Infinity/NaN
+        // in the pre-measure window. LinearGenomeView carries the same guard.
+        return self.bpPerPx === 0 ? 0 : this.totalBp / self.bpPerPx;
+    },
+    /**
+     * #getter
+     */
     get maxOffset() {
+        // objectively determined to keep the linear genome on the main screen
         const leftPadding = 10;
         return this.displayedRegionsTotalPx - leftPadding;
     },
+    /**
+     * #getter
+     */
     get minOffset() {
+        // objectively determined to keep the linear genome on the main screen
         const rightPadding = 30;
         return -this.width + rightPadding;
     },
+    /**
+     * #getter
+     */
     get totalBp() {
-        return sum(self.displayedRegions.map(a => a.end - a.start));
+        return self.displayedRegions.reduce((acc, r) => acc + r.end - r.start, 0);
     },
 }))
     .views(self => ({
+    /**
+     * #getter
+     */
     get dynamicBlocks() {
         return calculateDynamicBlocks(self);
     },
+    /**
+     * #getter
+     */
     get staticBlocks() {
         return calculateStaticBlocks(self);
     },
+    /**
+     * #getter
+     */
     get currBp() {
-        return sum(this.dynamicBlocks.map(a => a.end - a.start));
+        return this.dynamicBlocks.contentBlocks.reduce((acc, r) => acc + r.end - r.start, 0);
     },
 }))
     .views(self => ({
+    /**
+     * #method
+     */
     pxToBp(px) {
         return pxToBp(self, px);
     },
-    bpToPx({ refName, coord, regionNumber, }) {
-        return bpToPx({ refName, coord, regionNumber, self })?.offsetPx;
+    /**
+     * #method
+     */
+    bpToPx(args) {
+        return layoutBpToPx(self, args);
     },
 }))
     .actions(self => ({
-    setFeatures(features) {
-        self.features = features;
-    },
+    /**
+     * #action
+     * this makes a zoomed out view that shows all displayedRegions that makes
+     * the overview bar square with the scale bar
+     */
     showAllRegions() {
-        self.bpPerPx = self.totalBp / self.width;
+        // guard width=0 (pre-measure) so bpPerPx doesn't become Infinity/NaN
+        self.bpPerPx = self.totalBp / Math.max(self.width, 1);
         self.offsetPx = 0;
     },
+    /**
+     * #action
+     */
     zoomOut() {
         this.zoomTo(self.bpPerPx * 2);
     },
+    /**
+     * #action
+     */
     zoomIn() {
         this.zoomTo(self.bpPerPx / 2);
     },
+    /**
+     * #action
+     */
     zoomTo(bpPerPx, offset = self.width / 2) {
-        const newBpPerPx = clamp(bpPerPx, 'minBpPerPx' in self ? self.minBpPerPx : 0, 'maxBpPerPx' in self
-            ? self.maxBpPerPx
-            : Number.POSITIVE_INFINITY);
+        const newBpPerPx = clamp(bpPerPx, self.minBpPerPx, self.maxBpPerPx);
         const oldBpPerPx = self.bpPerPx;
-        if (Math.abs(oldBpPerPx - newBpPerPx) < 0.000001) {
-            return oldBpPerPx;
+        if (Math.abs(oldBpPerPx - newBpPerPx) >= 0.000001) {
+            self.bpPerPx = newBpPerPx;
+            // tweak the offset so that the center of the view remains at the same
+            // coordinate
+            self.offsetPx = clamp(Math.round(((self.offsetPx + offset) * oldBpPerPx) / newBpPerPx - offset), self.minOffset, self.maxOffset);
         }
-        self.bpPerPx = newBpPerPx;
-        self.offsetPx = clamp(Math.round(((self.offsetPx + offset) * oldBpPerPx) / newBpPerPx - offset), self.minOffset, self.maxOffset);
         return self.bpPerPx;
     },
+    /**
+     * #action
+     */
     scrollTo(offsetPx) {
         const newOffsetPx = clamp(offsetPx, self.minOffset, self.maxOffset);
         self.offsetPx = newOffsetPx;
         return newOffsetPx;
     },
-    centerAt(coord, refName, regionNumber) {
-        if (!refName) {
-            return;
-        }
-        const centerPx = self.bpToPx({
-            refName,
-            coord,
-            regionNumber,
-        });
-        if (centerPx) {
-            this.scrollTo(Math.round(centerPx - self.width / 2));
+    /**
+     * #action
+     */
+    centerAt(coord, refName, displayedRegionIndex) {
+        if (refName) {
+            const centerPx = self.bpToPx({
+                refName,
+                coord,
+                displayedRegionIndex,
+            });
+            if (centerPx !== undefined) {
+                this.scrollTo(Math.round(centerPx - self.width / 2));
+            }
         }
     },
+    /**
+     * #action
+     * note: the scroll is clamped to keep the view on the main screen
+     */
     scroll(distance) {
         const oldOffsetPx = self.offsetPx;
         const newOffsetPx = clamp(self.offsetPx + distance, self.minOffset, self.maxOffset);
@@ -122,6 +223,14 @@ const Base1DView = types
     },
 }))
     .actions(self => ({
+    /**
+     * #action
+     * offset is the base-pair-offset in the displayed region, index is the
+     * index of the displayed region in the linear genome view
+     *
+     * @param start - object as `{start, end, offset, index}`
+     * @param end - object as `{start, end, offset, index}`
+     */
     moveTo(start, end) {
         moveTo(self, start, end);
     },

package/esm/util/FileSaver/index.d.ts

@@ -0,0 +1 @@
+export declare function saveAs(blob: Blob | string, name?: string): void;

package/esm/util/FileSaver/index.js

@@ -0,0 +1,27 @@
+// Minimal `saveAs`. The name/API derive from FileSaver.js by Eli Grey
+// (https://github.com/eligrey/FileSaver.js, MIT), but this is reimplemented as
+// the modern anchor-download path only, dropping the legacy browser fallbacks.
+export function saveAs(blob, name) {
+    const filename = name || (blob instanceof File ? blob.name : '') || 'download';
+    const a = document.createElement('a');
+    a.download = filename;
+    a.rel = 'noopener';
+    if (typeof blob === 'string') {
+        a.href = blob;
+        if (new URL(a.href, window.location.href).origin !== window.location.origin) {
+            // Fallback for cross-origin URLs
+            a.target = '_blank';
+        }
+        a.click();
+    }
+    else {
+        const url = URL.createObjectURL(blob);
+        a.href = url;
+        setTimeout(() => {
+            a.click();
+        }, 0);
+        setTimeout(() => {
+            URL.revokeObjectURL(url);
+        }, 40000);
+    }
+}

package/esm/util/IntervalTree.d.ts

@@ -1,42 +1,21 @@
-declare const RB_TREE_COLOR_RED = 1;
-declare const RB_TREE_COLOR_BLACK = 0;
-type NodeColor = typeof RB_TREE_COLOR_RED | typeof RB_TREE_COLOR_BLACK;
-declare class Interval {
-    low: number;
-    high: number;
-    constructor(low: number, high: number);
-    lessThan(other: Interval): boolean;
-    equalTo(other: Interval): boolean;
-    intersects(other: Interval): boolean;
-    merge(other: Interval): Interval;
-}
-declare class Node<V> {
-    left: Node<V> | null;
-    right: Node<V> | null;
-    parent: Node<V> | null;
-    color: NodeColor;
-    key: Interval | undefined;
-    values: V[];
-    max: Interval | undefined;
-    constructor(key?: Interval | [number, number], value?: V, left?: Node<V> | null, right?: Node<V> | null, parent?: Node<V> | null, color?: NodeColor);
-    lessThan(other: Node<V>): boolean;
-    equalTo(other: Node<V>): boolean;
-    intersects(other: Node<V>): boolean;
-    updateMax(): void;
-    notIntersectLeftSubtree(searchNode: Node<V>): boolean;
-    notIntersectRightSubtree(searchNode: Node<V>): boolean;
-}
+/**
+ * Static augmented interval tree: returns the values whose interval overlaps a
+ * query interval.
+ *
+ * Replaces a vendored red-black implementation. Every JBrowse caller builds the
+ * tree fully (many `insert`s) and then only queries it (`search`) — never
+ * interleaving inserts with searches and never deleting — so the self-balancing
+ * machinery (rotations, color fixups, parent pointers, nil sentinels) was
+ * unnecessary. Intervals are collected on `insert`; a balanced tree is built
+ * lazily on the first `search` via recursive median split, giving O(n log n)
+ * build and O(log n + k) query.
+ *
+ * Originally vendored from @flatten-js/interval-tree (MIT, Alex Bol).
+ */
 export declare class IntervalTree<V> {
-    root: Node<V> | null;
-    private nilNode;
-    insert(key: [number, number], value: V): Node<V>;
+    private intervals;
+    private root;
+    private built;
+    insert(key: [number, number], value: V): void;
     search(interval: [number, number]): V[];
-    private recalcMax;
-    private treeInsert;
-    private insertFixup;
-    private treeSearch;
-    private treeSearchInterval;
-    private rotateLeft;
-    private rotateRight;
 }
-export {};

package/esm/util/IntervalTree.js

@@ -1,251 +1,70 @@
-const RB_TREE_COLOR_RED = 1;
-const RB_TREE_COLOR_BLACK = 0;
-class Interval {
-    low;
-    high;
-    constructor(low, high) {
-        this.low = low;
-        this.high = high;
-    }
-    lessThan(other) {
-        return (this.low < other.low || (this.low === other.low && this.high < other.high));
-    }
-    equalTo(other) {
-        return this.low === other.low && this.high === other.high;
-    }
-    intersects(other) {
-        return !(this.high < other.low || other.high < this.low);
-    }
-    merge(other) {
-        return new Interval(Math.min(this.low, other.low), Math.max(this.high, other.high));
-    }
-}
-class Node {
-    left = null;
-    right = null;
-    parent = null;
-    color = RB_TREE_COLOR_BLACK;
-    key;
-    values = [];
-    max;
-    constructor(key, value, left, right, parent, color) {
-        if (left !== undefined) {
-            this.left = left;
-        }
-        if (right !== undefined) {
-            this.right = right;
-        }
-        if (parent !== undefined) {
-            this.parent = parent;
-        }
-        if (color !== undefined) {
-            this.color = color;
-        }
-        if (value !== undefined) {
-            this.values.push(value);
-        }
-        if (key !== undefined) {
-            if (Array.isArray(key)) {
-                const [low, high] = key;
-                this.key =
-                    low <= high ? new Interval(low, high) : new Interval(high, low);
-            }
-            else {
-                this.key = key;
-            }
-            this.max = this.key;
-        }
-    }
-    lessThan(other) {
-        return this.key.lessThan(other.key);
-    }
-    equalTo(other) {
-        return this.key.equalTo(other.key);
-    }
-    intersects(other) {
-        return this.key.intersects(other.key);
-    }
-    updateMax() {
-        this.max = this.key;
-        if (this.right?.max && this.max) {
-            this.max = this.max.merge(this.right.max);
-        }
-        if (this.left?.max && this.max) {
-            this.max = this.max.merge(this.left.max);
-        }
-    }
-    notIntersectLeftSubtree(searchNode) {
-        if (!this.left) {
-            return true;
-        }
-        const high = this.left.max?.high ?? this.left.key.high;
-        return high < searchNode.key.low;
-    }
-    notIntersectRightSubtree(searchNode) {
-        if (!this.right) {
-            return true;
-        }
-        const low = this.right.max?.low ?? this.right.key.low;
-        return searchNode.key.high < low;
-    }
-}
+/**
+ * Static augmented interval tree: returns the values whose interval overlaps a
+ * query interval.
+ *
+ * Replaces a vendored red-black implementation. Every JBrowse caller builds the
+ * tree fully (many `insert`s) and then only queries it (`search`) — never
+ * interleaving inserts with searches and never deleting — so the self-balancing
+ * machinery (rotations, color fixups, parent pointers, nil sentinels) was
+ * unnecessary. Intervals are collected on `insert`; a balanced tree is built
+ * lazily on the first `search` via recursive median split, giving O(n log n)
+ * build and O(log n + k) query.
+ *
+ * Originally vendored from @flatten-js/interval-tree (MIT, Alex Bol).
+ */
 export class IntervalTree {
-    root = null;
-    nilNode = new Node();
+    intervals = [];
+    root;
+    built = false;
     insert(key, value) {
-        const existing = this.treeSearch(this.root, new Node(key));
-        if (existing) {
-            existing.values.push(value);
-            return existing;
-        }
-        const insertNode = new Node(key, value, this.nilNode, this.nilNode, null, RB_TREE_COLOR_RED);
-        this.treeInsert(insertNode);
-        this.recalcMax(insertNode);
-        return insertNode;
+        const [a, b] = key;
+        // normalize reversed intervals so low <= high
+        this.intervals.push({ low: Math.min(a, b), high: Math.max(a, b), value });
+        this.built = false;
     }
     search(interval) {
-        const searchNode = new Node(interval);
-        const resultNodes = [];
-        this.treeSearchInterval(this.root, searchNode, resultNodes);
-        return resultNodes.flatMap(node => node.values);
-    }
-    recalcMax(node) {
-        let current = node;
-        while (current.parent != null) {
-            current.parent.updateMax();
-            current = current.parent;
-        }
-    }
-    treeInsert(insertNode) {
-        let current = this.root;
-        let parent = null;
-        if (this.root == null || this.root === this.nilNode) {
-            this.root = insertNode;
-        }
-        else {
-            while (current !== this.nilNode) {
-                parent = current;
-                current = insertNode.lessThan(current) ? current.left : current.right;
-            }
-            insertNode.parent = parent;
-            if (insertNode.lessThan(parent)) {
-                parent.left = insertNode;
-            }
-            else {
-                parent.right = insertNode;
-            }
-        }
-        this.insertFixup(insertNode);
-    }
-    insertFixup(insertNode) {
-        let current = insertNode;
-        while (current !== this.root &&
-            current.parent.color === RB_TREE_COLOR_RED) {
-            if (current.parent === current.parent.parent.left) {
-                const uncle = current.parent.parent.right;
-                if (uncle.color === RB_TREE_COLOR_RED) {
-                    current.parent.color = RB_TREE_COLOR_BLACK;
-                    uncle.color = RB_TREE_COLOR_BLACK;
-                    current.parent.parent.color = RB_TREE_COLOR_RED;
-                    current = current.parent.parent;
-                }
-                else {
-                    if (current === current.parent.right) {
-                        current = current.parent;
-                        this.rotateLeft(current);
-                    }
-                    current.parent.color = RB_TREE_COLOR_BLACK;
-                    current.parent.parent.color = RB_TREE_COLOR_RED;
-                    this.rotateRight(current.parent.parent);
-                }
-            }
-            else {
-                const uncle = current.parent.parent.left;
-                if (uncle.color === RB_TREE_COLOR_RED) {
-                    current.parent.color = RB_TREE_COLOR_BLACK;
-                    uncle.color = RB_TREE_COLOR_BLACK;
-                    current.parent.parent.color = RB_TREE_COLOR_RED;
-                    current = current.parent.parent;
-                }
-                else {
-                    if (current === current.parent.left) {
-                        current = current.parent;
-                        this.rotateRight(current);
-                    }
-                    current.parent.color = RB_TREE_COLOR_BLACK;
-                    current.parent.parent.color = RB_TREE_COLOR_RED;
-                    this.rotateLeft(current.parent.parent);
-                }
-            }
-        }
-        this.root.color = RB_TREE_COLOR_BLACK;
-    }
-    treeSearch(node, searchNode) {
-        if (node == null || node === this.nilNode) {
-            return undefined;
-        }
-        if (searchNode.equalTo(node)) {
-            return node;
-        }
-        return searchNode.lessThan(node)
-            ? this.treeSearch(node.left, searchNode)
-            : this.treeSearch(node.right, searchNode);
-    }
-    treeSearchInterval(node, searchNode, results) {
-        if (node != null && node !== this.nilNode) {
-            if (node.left !== this.nilNode &&
-                !node.notIntersectLeftSubtree(searchNode)) {
-                this.treeSearchInterval(node.left, searchNode, results);
-            }
-            if (node.intersects(searchNode)) {
-                results.push(node);
-            }
-            if (node.right !== this.nilNode &&
-                !node.notIntersectRightSubtree(searchNode)) {
-                this.treeSearchInterval(node.right, searchNode, results);
-            }
-        }
-    }
-    rotateLeft(x) {
-        const y = x.right;
-        x.right = y.left;
-        if (y.left !== this.nilNode) {
-            y.left.parent = x;
-        }
-        y.parent = x.parent;
-        if (x === this.root) {
-            this.root = y;
-        }
-        else if (x === x.parent.left) {
-            x.parent.left = y;
-        }
-        else {
-            x.parent.right = y;
-        }
-        y.left = x;
-        x.parent = y;
-        x.updateMax();
-        y.updateMax();
+        if (!this.built) {
+            // stable sort keeps insertion order among equal intervals, so the
+            // in-order query output matches the old red-black in-order traversal
+            const sorted = [...this.intervals].sort((x, y) => x.low - y.low || x.high - y.high);
+            this.root = buildBalanced(sorted, 0, sorted.length - 1);
+            this.built = true;
+        }
+        const [a, b] = interval;
+        const out = [];
+        query(this.root, Math.min(a, b), Math.max(a, b), out);
+        return out;
     }
-    rotateRight(y) {
-        const x = y.left;
-        y.left = x.right;
-        if (x.right !== this.nilNode) {
-            x.right.parent = y;
-        }
-        x.parent = y.parent;
-        if (y === this.root) {
-            this.root = x;
-        }
-        else if (y === y.parent.left) {
-            y.parent.left = x;
-        }
-        else {
-            y.parent.right = x;
-        }
-        x.right = y;
-        y.parent = x;
-        y.updateMax();
-        x.updateMax();
+}
+function buildBalanced(items, start, end) {
+    if (start > end) {
+        return undefined;
+    }
+    const mid = Math.floor((start + end) / 2);
+    const item = items[mid];
+    const left = buildBalanced(items, start, mid - 1);
+    const right = buildBalanced(items, mid + 1, end);
+    return {
+        ...item,
+        left,
+        right,
+        maxHigh: Math.max(item.high, left?.maxHigh ?? -Infinity, right?.maxHigh ?? -Infinity),
+    };
+}
+// in-order overlap collection: left before self before right keeps results
+// sorted by (low, high), matching what the old red-black tree returned
+function query(node, low, high, out) {
+    // no interval in this subtree reaches `low`
+    if (!node || node.maxHigh < low) {
+        return;
+    }
+    query(node.left, low, high, out);
+    if (node.low <= high && node.high >= low) {
+        out.push(node.value);
+    }
+    // right subtree lows are all >= node.low (input is sorted by low); if
+    // node.low is already past `high`, nothing on the right can overlap
+    if (node.low <= high) {
+        query(node.right, low, high, out);
     }
 }