@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/Base1DViewModel.d.ts

@@ -1,60 +1,138 @@
 import type { BpOffset } from './Base1DUtils.ts';
-import type { Feature } from './simpleFeature.ts';
-import type { Region as IRegion } from './types/index.ts';
+import type { Region as IRegion } from './types/data.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
+/**
+ * #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
+ */
 declare const Base1DView: import("@jbrowse/mobx-state-tree").IModelType<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     displayedRegions: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<IRegion[], IRegion[], IRegion[]>, [undefined]>;
     bpPerPx: import("@jbrowse/mobx-state-tree").IType<number | undefined, number, number>;
     offsetPx: import("@jbrowse/mobx-state-tree").IType<number | undefined, number, number>;
-    interRegionPaddingWidth: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<number>, [undefined]>;
     minimumBlockWidth: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<number>, [undefined]>;
 }, {
-    features: undefined | Feature[];
     volatileWidth: number;
 } & {
+    /**
+     * #action
+     */
     setDisplayedRegions(regions: IRegion[]): void;
+    /**
+     * #action
+     */
     setBpPerPx(val: number): void;
+    /**
+     * #action
+     */
     setVolatileWidth(width: number): void;
 } & {
+    /**
+     * #getter
+     */
     readonly width: number;
+    /**
+     * #getter
+     * zoom-in floor; overridden by extensions (e.g. the dotplot axes)
+     */
+    readonly minBpPerPx: number;
+    /**
+     * #getter
+     * zoom-out ceiling; overridden by extensions (e.g. the dotplot axes)
+     */
+    readonly maxBpPerPx: number;
+    /**
+     * #getter
+     */
     readonly assemblyNames: string[];
+    /**
+     * #getter
+     */
     readonly displayedRegionsTotalPx: number;
+    /**
+     * #getter
+     */
     readonly maxOffset: number;
+    /**
+     * #getter
+     */
     readonly minOffset: number;
+    /**
+     * #getter
+     */
     readonly totalBp: number;
 } & {
+    /**
+     * #getter
+     */
     readonly dynamicBlocks: import("./blockTypes.ts").BlockSet;
+    /**
+     * #getter
+     */
     readonly staticBlocks: import("./blockTypes.ts").BlockSet;
+    /**
+     * #getter
+     */
     readonly currBp: number;
 } & {
-    pxToBp(px: number): {
-        coord: number;
-        index: number;
-        refName: string;
-        oob: boolean;
-        assemblyName: string;
-        offset: number;
-        start: number;
-        end: number;
-        reversed?: boolean;
-    };
-    bpToPx({ refName, coord, regionNumber, }: {
+    /**
+     * #method
+     */
+    pxToBp(px: number): import("./Base1DUtils.ts").PxToBpResult;
+    /**
+     * #method
+     */
+    bpToPx(args: {
         refName: string;
         coord: number;
-        regionNumber?: number;
+        displayedRegionIndex?: number;
     }): number | undefined;
 } & {
-    setFeatures(features: Feature[]): void;
+    /**
+     * #action
+     * this makes a zoomed out view that shows all displayedRegions that makes
+     * the overview bar square with the scale bar
+     */
     showAllRegions(): void;
+    /**
+     * #action
+     */
     zoomOut(): void;
+    /**
+     * #action
+     */
     zoomIn(): void;
-    zoomTo(bpPerPx: number, offset?: number): number;
+    /**
+     * #action
+     */
+    zoomTo(bpPerPx: number, offset?: any): number;
+    /**
+     * #action
+     */
     scrollTo(offsetPx: number): number;
-    centerAt(coord: number, refName: string | undefined, regionNumber: number): void;
+    /**
+     * #action
+     */
+    centerAt(coord: number, refName: string | undefined, displayedRegionIndex: number): void;
+    /**
+     * #action
+     * note: the scroll is clamped to keep the view on the main screen
+     */
     scroll(distance: number): number;
 } & {
-    moveTo(start?: BpOffset, end?: BpOffset): void;
+    /**
+     * #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}`
+     * @param minBpPerPx - zoom no further in than this, centering the span
+     */
+    moveTo(start?: BpOffset, end?: BpOffset, minBpPerPx?: number): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export type Base1DViewStateModel = typeof Base1DView;
 export type Base1DViewModel = Instance<Base1DViewStateModel>;

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,8 +223,17 @@ const Base1DView = types
     },
 }))
     .actions(self => ({
-    moveTo(start, end) {
-        moveTo(self, start, end);
+    /**
+     * #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}`
+     * @param minBpPerPx - zoom no further in than this, centering the span
+     */
+    moveTo(start, end, minBpPerPx) {
+        moveTo(self, start, end, minBpPerPx);
     },
 }));
 export default Base1DView;

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 {};