@jbrowse/core 3.7.0 → 4.0.0

package/esm/util/layouts/PileupLayout.js

@@ -0,0 +1,202 @@
+import { findInsertionPoint, insertInterval, isRangeClear, } from "./intervalUtils.js";
+export default class PileupLayout {
+    featureHeight;
+    spacing;
+    rowHeight;
+    padding;
+    maxRows;
+    rows = [];
+    rowMaxEnd = [];
+    rectangles = new Map();
+    lastLeft = -Infinity;
+    lastRow = 0;
+    maxHeightReached = false;
+    constructor(options = {}) {
+        this.featureHeight = options.featureHeight ?? 7;
+        this.spacing = options.spacing ?? 0;
+        this.rowHeight = this.featureHeight + this.spacing;
+        this.padding = options.padding ?? 1;
+        this.maxRows = options.maxHeight
+            ? Math.floor(options.maxHeight / this.rowHeight)
+            : 100000;
+    }
+    addRect(id, left, right, height, data, serializableData) {
+        const existing = this.rectangles.get(id);
+        if (existing) {
+            if (existing.top === null) {
+                return null;
+            }
+            return existing.top * this.rowHeight;
+        }
+        let startRow = 0;
+        if (left === this.lastLeft) {
+            startRow = this.lastRow + 1;
+        }
+        const paddedRight = right + this.padding;
+        const row = this.findFreeRow(left, paddedRight, startRow);
+        if (row === null) {
+            const rect = {
+                id,
+                l: left,
+                r: right,
+                top: null,
+                h: 1,
+                originalHeight: this.featureHeight,
+                data,
+                serializableData,
+            };
+            this.rectangles.set(id, rect);
+            this.maxHeightReached = true;
+            return null;
+        }
+        this.addToRow(row, left, paddedRight);
+        const rect = {
+            id,
+            l: left,
+            r: right,
+            top: row,
+            h: 1,
+            originalHeight: this.featureHeight,
+            data,
+            serializableData,
+        };
+        this.rectangles.set(id, rect);
+        this.lastLeft = left;
+        this.lastRow = row;
+        return row * this.rowHeight;
+    }
+    findFreeRow(left, right, startRow) {
+        const rows = this.rows;
+        const rowMaxEnd = this.rowMaxEnd;
+        for (let row = startRow; row < this.maxRows; row++) {
+            const intervals = rows[row];
+            if (!intervals) {
+                return row;
+            }
+            if (left >= rowMaxEnd[row]) {
+                return row;
+            }
+            if (isRangeClear(intervals, left, right)) {
+                return row;
+            }
+        }
+        return null;
+    }
+    addToRow(rowIdx, left, right) {
+        let intervals = this.rows[rowIdx];
+        if (!intervals) {
+            intervals = [];
+            this.rows[rowIdx] = intervals;
+            this.rowMaxEnd[rowIdx] = 0;
+        }
+        const len = intervals.length;
+        if (len === 0 || left >= intervals[len - 2]) {
+            intervals.push(left, right);
+        }
+        else {
+            const idx = findInsertionPoint(intervals, left);
+            insertInterval(intervals, idx, left, right);
+        }
+        if (right > this.rowMaxEnd[rowIdx]) {
+            this.rowMaxEnd[rowIdx] = right;
+        }
+    }
+    collides(_rect, _top) {
+        return false;
+    }
+    addRectToBitmap(_rect) {
+    }
+    getTotalHeight() {
+        let maxRow = 0;
+        for (let i = this.rows.length - 1; i >= 0; i--) {
+            if (this.rows[i]) {
+                maxRow = i + 1;
+                break;
+            }
+        }
+        return maxRow * this.rowHeight;
+    }
+    getRectangles() {
+        const result = new Map();
+        const rowHeight = this.rowHeight;
+        const featureHeight = this.featureHeight;
+        for (const [id, rect] of this.rectangles) {
+            if (rect.top !== null) {
+                const top = rect.top * rowHeight;
+                result.set(id, [rect.l, top, rect.r, top + featureHeight]);
+            }
+        }
+        return result;
+    }
+    discardRange(left, right) {
+        for (let rowIdx = 0; rowIdx < this.rows.length; rowIdx++) {
+            const intervals = this.rows[rowIdx];
+            if (!intervals) {
+                continue;
+            }
+            const newIntervals = [];
+            let maxEnd = 0;
+            for (let i = 0; i < intervals.length; i += 2) {
+                const start = intervals[i];
+                const end = intervals[i + 1];
+                if (end <= left || start >= right) {
+                    newIntervals.push(start, end);
+                    if (end > maxEnd) {
+                        maxEnd = end;
+                    }
+                }
+                else if (start < left && end > left && end <= right) {
+                    newIntervals.push(start, left);
+                    if (left > maxEnd) {
+                        maxEnd = left;
+                    }
+                }
+                else if (start >= left && start < right && end > right) {
+                    newIntervals.push(right, end);
+                    if (end > maxEnd) {
+                        maxEnd = end;
+                    }
+                }
+                else if (start < left && end > right) {
+                    newIntervals.push(start, left, right, end);
+                    if (end > maxEnd) {
+                        maxEnd = end;
+                    }
+                }
+            }
+            this.rows[rowIdx] = newIntervals;
+            this.rowMaxEnd[rowIdx] = maxEnd;
+        }
+        this.lastLeft = -Infinity;
+        this.lastRow = 0;
+    }
+    getDataByID(id) {
+        return this.rectangles.get(id)?.data;
+    }
+    serializeRegion(region) {
+        const { start: x1, end: x2 } = region;
+        const regionRectangles = {};
+        for (const [id, rect] of this.rectangles.entries()) {
+            if (rect.top === null) {
+                continue;
+            }
+            const { l, r, top } = rect;
+            if (x2 >= l && r >= x1) {
+                const topPx = top * this.rowHeight;
+                regionRectangles[id] = [l, topPx, r, topPx + this.featureHeight];
+            }
+        }
+        return {
+            rectangles: regionRectangles,
+            totalHeight: this.getTotalHeight(),
+            maxHeightReached: this.maxHeightReached,
+        };
+    }
+    toJSON() {
+        return {
+            rectangles: Object.fromEntries(this.getRectangles()),
+            totalHeight: this.getTotalHeight(),
+            maxHeightReached: this.maxHeightReached,
+        };
+    }
+}

package/esm/util/layouts/PrecomputedLayout.d.ts

@@ -0,0 +1,30 @@
+import type { BaseLayout, RectTuple, Rectangle, SerializedLayout } from './BaseLayout.ts';
+export interface Layout {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    name: string;
+}
+export default class PrecomputedLayout<T> implements BaseLayout<T> {
+    private rectangles;
+    private totalHeight;
+    maxHeightReached: boolean;
+    private index?;
+    private indexData;
+    constructor({ rectangles, totalHeight, maxHeightReached }: SerializedLayout);
+    private buildIndex;
+    addRect(id: string): number;
+    getRectangles(): Map<string, RectTuple>;
+    getTotalHeight(): number;
+    collides(_rect: Rectangle<T>, _top: number): boolean;
+    getByCoord(x: number, y: number): string | undefined;
+    getByID(id: string): RectTuple | undefined;
+    addRectToBitmap(_rect: Rectangle<T>, _data: Record<string, T>): void;
+    discardRange(_left: number, _right: number): void;
+    serializeRegion(_region: {
+        start: number;
+        end: number;
+    }): SerializedLayout;
+    toJSON(): SerializedLayout;
+}

package/esm/util/layouts/PrecomputedLayout.js

@@ -0,0 +1,71 @@
+import Flatbush from "../flatbush/index.js";
+export default class PrecomputedLayout {
+    rectangles;
+    totalHeight;
+    maxHeightReached;
+    index;
+    indexData = [];
+    constructor({ rectangles, totalHeight, maxHeightReached }) {
+        this.rectangles = new Map(Object.entries(rectangles));
+        this.totalHeight = totalHeight;
+        this.maxHeightReached = maxHeightReached;
+        this.buildIndex();
+    }
+    buildIndex() {
+        if (this.rectangles.size === 0) {
+            return;
+        }
+        this.index = new Flatbush(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);
+        if (!rect) {
+            throw new Error(`id ${id} not found in precomputed feature layout`);
+        }
+        return rect[1];
+    }
+    getRectangles() {
+        return this.rectangles;
+    }
+    getTotalHeight() {
+        return this.totalHeight;
+    }
+    collides(_rect, _top) {
+        throw new Error('Method not implemented.');
+    }
+    getByCoord(x, y) {
+        if (!this.index) {
+            return undefined;
+        }
+        const results = this.index.search(x, y, x + 1, y + 1);
+        if (results.length > 0) {
+            return this.indexData[results[0]]?.name;
+        }
+        return undefined;
+    }
+    getByID(id) {
+        return this.rectangles.get(id);
+    }
+    addRectToBitmap(_rect, _data) {
+        throw new Error('Method not implemented.');
+    }
+    discardRange(_left, _right) {
+        throw new Error('Method not implemented.');
+    }
+    serializeRegion(_region) {
+        throw new Error('Method not implemented.');
+    }
+    toJSON() {
+        return {
+            rectangles: Object.fromEntries(this.rectangles),
+            totalHeight: this.totalHeight,
+            maxHeightReached: false,
+        };
+    }
+}

package/esm/util/layouts/SceneGraph.js

@@ -0,0 +1,121 @@
+export default class SceneGraph {
+    name;
+    left;
+    top;
+    width;
+    height;
+    data;
+    children;
+    absoluteCache;
+    parent;
+    constructor(name, left, top, width, height, data) {
+        this.name = name;
+        this.left = left;
+        this.top = top;
+        this.width = width;
+        this.height = height;
+        this.data = data;
+        this.children = new Map();
+        this.absoluteCache = { dirty: true };
+    }
+    addChild(nameOrSceneGraph, left, top, width, height, data) {
+        const child = nameOrSceneGraph instanceof SceneGraph
+            ? nameOrSceneGraph
+            : new SceneGraph(nameOrSceneGraph, left, top, width, height, data);
+        if (!(child instanceof SceneGraph)) {
+            throw new TypeError('argument to addChild must be an array or a SceneGraph');
+        }
+        if (this.children.has(child.name)) {
+            throw new Error(`child named "${child.name}" already exists`);
+        }
+        child.parent = this;
+        const { left: childLeft, right: childRight, top: childTop, bottom: childBottom, } = child.absolute;
+        if (childLeft !== undefined &&
+            childRight !== undefined &&
+            childTop !== undefined &&
+            childBottom !== undefined) {
+            this.expand(childLeft, childRight, childTop, childBottom);
+            this.children.set(child.name, child);
+        }
+        return child;
+    }
+    getSubRecord(name) {
+        return this.children.get(name);
+    }
+    expand(newLeft, newRight, newTop, newBottom) {
+        const { left, right, top, bottom } = this.absolute;
+        if (left !== undefined && newLeft < left) {
+            const diff = left - newLeft;
+            this.width += diff;
+            this.left -= diff;
+        }
+        if (right !== undefined && newRight > right) {
+            this.width += newRight - right;
+        }
+        if (top !== undefined && newTop < top) {
+            const diff = top - newTop;
+            this.height += diff;
+            this.top -= diff;
+        }
+        if (bottom !== undefined && newBottom > bottom) {
+            this.height += newBottom - bottom;
+        }
+        if (this.parent) {
+            this.parent.expand(newLeft, newRight, newTop, newBottom);
+        }
+        this.absoluteCache.dirty = true;
+    }
+    get bottom() {
+        return this.top + this.height;
+    }
+    get right() {
+        return this.left + this.width;
+    }
+    walkParents(callback) {
+        if (this.parent) {
+            callback(this.parent);
+            this.parent.walkParents(callback);
+        }
+    }
+    walkChildren(callback) {
+        for (const sub of this.children.values()) {
+            callback(sub);
+            sub.walkChildren(callback);
+        }
+    }
+    get absolute() {
+        if (this.absoluteCache.dirty) {
+            let xOffset = 0;
+            let yOffset = 0;
+            this.walkParents((node) => {
+                xOffset += node.left;
+                yOffset += node.top;
+            });
+            this.absoluteCache = {
+                dirty: false,
+                left: this.left + xOffset,
+                right: this.right + xOffset,
+                top: this.top + yOffset,
+                bottom: this.bottom + yOffset,
+                width: this.width,
+                height: this.height,
+            };
+        }
+        return this.absoluteCache;
+    }
+    move(x, y) {
+        this.left += x;
+        this.top += y;
+        this.absoluteCache.dirty = true;
+        this.walkChildren(c => {
+            c.absoluteCache.dirty = true;
+        });
+        const { left, right, top, bottom } = this.absolute;
+        if (left !== undefined &&
+            right !== undefined &&
+            top !== undefined &&
+            bottom !== undefined) {
+            this.expand(left, right, top, bottom);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+export * from './BaseLayout.ts';
+export { default as GranularRectLayout } from './GranularRectLayout.ts';
+export { default as MultiLayout } from './MultiLayout.ts';
+export { default as PileupLayout } from './PileupLayout.ts';
+export type { PileupLayoutOptions, PileupRectangle } from './PileupLayout.ts';
+export { default as PrecomputedLayout } from './PrecomputedLayout.ts';
+export type { Layout } from './PrecomputedLayout.ts';
+export { default as SceneGraph } from './SceneGraph.ts';

package/esm/util/layouts/index.js

@@ -0,0 +1,6 @@
+export * from "./BaseLayout.js";
+export { default as GranularRectLayout } from "./GranularRectLayout.js";
+export { default as MultiLayout } from "./MultiLayout.js";
+export { default as PileupLayout } from "./PileupLayout.js";
+export { default as PrecomputedLayout } from "./PrecomputedLayout.js";
+export { default as SceneGraph } from "./SceneGraph.js";

package/esm/util/layouts/intervalUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function isRangeClear(intervals: number[], left: number, right: number): boolean;
+export declare function findInsertionPoint(intervals: number[], left: number): number;
+export declare function insertInterval(intervals: number[], idx: number, left: number, right: number): void;

package/esm/util/layouts/intervalUtils.js

@@ -0,0 +1,63 @@
+export function isRangeClear(intervals, left, right) {
+    const len = intervals.length;
+    if (len === 0) {
+        return true;
+    }
+    if (len < 40) {
+        for (let i = 0; i < len; i += 2) {
+            if (intervals[i + 1] > left && intervals[i] < right) {
+                return false;
+            }
+        }
+        return true;
+    }
+    let low = 0;
+    let high = len >> 1;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const midIdx = mid << 1;
+        if (intervals[midIdx + 1] <= left) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    const idx = low << 1;
+    if (idx >= len) {
+        return true;
+    }
+    return intervals[idx] >= right;
+}
+export function findInsertionPoint(intervals, left) {
+    const len = intervals.length;
+    if (len < 40) {
+        for (let i = 0; i < len; i += 2) {
+            if (left < intervals[i]) {
+                return i;
+            }
+        }
+        return len;
+    }
+    let low = 0;
+    let high = len >> 1;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (intervals[mid << 1] < left) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low << 1;
+}
+export function insertInterval(intervals, idx, left, right) {
+    const len = intervals.length;
+    intervals.push(0, 0);
+    for (let i = len + 1; i > idx + 1; i--) {
+        intervals[i] = intervals[i - 2];
+    }
+    intervals[idx] = left;
+    intervals[idx + 1] = right;
+}

package/esm/util/librpc.d.ts

@@ -0,0 +1,2 @@
+export { RpcClient, RpcServer, deserializeError, rpcResult, serializeError, } from 'librpc-web-mod';
+export type { RpcResult } from 'librpc-web-mod';

package/esm/util/librpc.js

@@ -0,0 +1 @@
+export { RpcClient, RpcServer, deserializeError, rpcResult, serializeError, } from 'librpc-web-mod';

package/esm/util/linkify.d.ts

@@ -0,0 +1 @@
+export declare function linkify(s: string): string;

package/esm/util/linkify.js

@@ -0,0 +1,5 @@
+const URL_PATTERN = /(^|[\s\n]|<[A-Za-z]*\/?>)((?:https?|ftp):\/\/[-A-Z0-9+\u0026\u2019@#/%?=()~_|!:,.;]*[-A-Z0-9+\u0026@#/%=~()_|])/gi;
+export function linkify(s) {
+    URL_PATTERN.lastIndex = 0;
+    return s.replace(URL_PATTERN, '$1<a href=\'$2\' target="_blank">$2</a>');
+}

package/esm/util/locString.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedLocString {
+    assemblyName?: string;
+    refName: string;
+    start?: number;
+    end?: number;
+    reversed?: boolean;
+}
+export declare function parseLocStringOneBased(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
+export declare function parseLocString(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;

package/esm/util/locString.js

@@ -0,0 +1,62 @@
+const COORD_REGEX = /^(-?\d+)(?:(?:\.\.|[-–])(-?\d+))?(\.\.|[-–])?$/;
+const ASSEMBLY_REGEX = /^(?:\{([^}]+)\})?(.+)/;
+function parseCoords(suffix, locString) {
+    const match = COORD_REGEX.exec(suffix.replaceAll(',', ''));
+    if (!match) {
+        throw new Error(`could not parse range "${suffix}" on location "${locString}"`);
+    }
+    const [, startStr, endStr, trailing] = match;
+    const start = +startStr;
+    return { start, end: endStr ? +endStr : trailing ? undefined : start };
+}
+export function parseLocStringOneBased(locString, isValidRefName) {
+    if (!locString) {
+        throw new Error('no location string provided, could not parse');
+    }
+    let reversed = false;
+    if (locString.endsWith('[rev]')) {
+        reversed = true;
+        locString = locString.slice(0, -5);
+    }
+    locString = locString.replaceAll(/\s/g, '');
+    const assemblyMatch = ASSEMBLY_REGEX.exec(locString);
+    if (!assemblyMatch) {
+        throw new Error(`invalid location string: "${locString}"`);
+    }
+    const [, assemblyName, location] = assemblyMatch;
+    if (!assemblyName && location.startsWith('{}')) {
+        throw new Error(`no assembly name was provided in location "${location}"`);
+    }
+    const lastColonIdx = location.lastIndexOf(':');
+    if (lastColonIdx === -1) {
+        if (isValidRefName(location, assemblyName)) {
+            return { assemblyName, refName: location, reversed };
+        }
+        throw new Error(`Unknown feature or sequence "${location}"`);
+    }
+    const prefix = location.slice(0, lastColonIdx);
+    const suffix = location.slice(lastColonIdx + 1);
+    const prefixValid = isValidRefName(prefix, assemblyName);
+    const locationValid = isValidRefName(location, assemblyName);
+    if (prefixValid && locationValid) {
+        throw new Error(`ambiguous location string: "${locString}"`);
+    }
+    if (locationValid) {
+        return { assemblyName, refName: location, reversed };
+    }
+    if (prefixValid) {
+        if (!suffix) {
+            return { assemblyName, refName: prefix, reversed };
+        }
+        const coords = parseCoords(suffix, locString);
+        return { assemblyName, refName: prefix, reversed, ...coords };
+    }
+    throw new Error(`unknown reference sequence name in location "${locString}"`);
+}
+export function parseLocString(locString, isValidRefName) {
+    const parsed = parseLocStringOneBased(locString, isValidRefName);
+    if (typeof parsed.start === 'number') {
+        parsed.start -= 1;
+    }
+    return parsed;
+}

package/esm/util/makeAbortableReaction.d.ts

@@ -0,0 +1,3 @@
+import type { StopToken } from './stopToken.ts';
+import type { IReactionOptions, IReactionPublic } from 'mobx';
+export declare function makeAbortableReaction<T, U, V>(self: T, dataFunction: (arg: T) => U, asyncReactionFunction: (arg: U | undefined, stopToken: StopToken, model: T, handle: IReactionPublic) => Promise<V>, reactionOptions: IReactionOptions, startedFunction: (stopToken: StopToken) => void, successFunction: (arg: V) => void, errorFunction: (err: unknown) => void): void;

package/esm/util/makeAbortableReaction.js

@@ -0,0 +1,47 @@
+import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree';
+import { reaction } from 'mobx';
+import { isAbortException } from "./aborting.js";
+import { createStopToken, stopStopToken } from "./stopToken.js";
+export function makeAbortableReaction(self, dataFunction, asyncReactionFunction, reactionOptions, startedFunction, successFunction, errorFunction) {
+    let inProgress;
+    function handleError(error) {
+        if (!isAbortException(error)) {
+            if (isAlive(self)) {
+                console.error(error);
+                errorFunction(error);
+            }
+        }
+    }
+    addDisposer(self, reaction(() => {
+        try {
+            return dataFunction(self);
+        }
+        catch (e) {
+            handleError(e);
+            return undefined;
+        }
+    }, async (data, mobxReactionHandle) => {
+        if (inProgress) {
+            stopStopToken(inProgress);
+        }
+        if (!isAlive(self)) {
+            return;
+        }
+        inProgress = createStopToken();
+        startedFunction(inProgress);
+        try {
+            const result = await asyncReactionFunction(data, inProgress, self, mobxReactionHandle);
+            if (isAlive(self)) {
+                successFunction(result);
+            }
+        }
+        catch (e) {
+            handleError(e);
+        }
+    }, reactionOptions));
+    addDisposer(self, () => {
+        if (inProgress) {
+            stopStopToken(inProgress);
+        }
+    });
+}

package/esm/util/map-obj/index.d.ts

@@ -0,0 +1,13 @@
+export declare const mapObjectSkip: unique symbol;
+export interface Options {
+    readonly deep?: boolean;
+    readonly includeSymbols?: boolean;
+    readonly target?: Record<string | symbol, unknown>;
+}
+export interface MapperOptions {
+    readonly shouldRecurse?: boolean;
+}
+type MapperResult<K extends string | symbol, V> = [targetKey: K, targetValue: V, mapperOptions?: MapperOptions] | typeof mapObjectSkip;
+export type Mapper<SourceObjectType extends Record<string | symbol, unknown>, MappedObjectKeyType extends string | symbol, MappedObjectValueType> = (sourceKey: string, sourceValue: unknown, source: SourceObjectType) => MapperResult<MappedObjectKeyType, MappedObjectValueType>;
+export default function mapObject<SourceObjectType extends Record<string | symbol, unknown>, MappedObjectKeyType extends string | symbol, MappedObjectValueType>(object: SourceObjectType, mapper: Mapper<SourceObjectType, MappedObjectKeyType, MappedObjectValueType>, options?: Options): Record<MappedObjectKeyType, MappedObjectValueType>;
+export {};