@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/compositeMap.d.ts

@@ -1,11 +0,0 @@
-export default class CompositeMap<T, U> {
-    private submaps;
-    constructor(submaps: Map<T, U>[]);
-    has(id: T): boolean;
-    get(id: T): U | undefined;
-    values(): Generator<U, void, unknown>;
-    keys(): Generator<T, void, unknown>;
-    find<V>(f: (arg0: U) => V): U | undefined;
-    [Symbol.iterator](): Generator<readonly [T, U | undefined], void, unknown>;
-    entries(): Generator<readonly [T, U | undefined], void, unknown>;
-}

package/esm/util/compositeMap.js

@@ -1,59 +0,0 @@
-export default class CompositeMap {
-    submaps;
-    constructor(submaps) {
-        this.submaps = submaps;
-    }
-    has(id) {
-        for (const submap of this.submaps.values()) {
-            if (submap.has(id)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    get(id) {
-        for (const submap of this.submaps.values()) {
-            if (submap.has(id)) {
-                return submap.get(id);
-            }
-        }
-        return undefined;
-    }
-    *values() {
-        for (const key of this.keys()) {
-            yield this.get(key);
-        }
-    }
-    *keys() {
-        const keys = new Set();
-        for (const submap of this.submaps.values()) {
-            for (const key of submap.keys()) {
-                keys.add(key);
-            }
-        }
-        for (const key of keys) {
-            yield key;
-        }
-    }
-    find(f) {
-        for (const submap of this.submaps.values()) {
-            for (const value of submap.values()) {
-                const found = f(value);
-                if (found) {
-                    return value;
-                }
-            }
-        }
-        return undefined;
-    }
-    *[Symbol.iterator]() {
-        for (const key of this.keys()) {
-            yield [key, this.get(key)];
-        }
-    }
-    *entries() {
-        for (const k of this.keys()) {
-            yield [k, this.get(k)];
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-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/esm/util/flatqueue/index.js

@@ -1,61 +0,0 @@
-export default class FlatQueue {
-    ids = [];
-    values = [];
-    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;
-    }
-}

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

@@ -1,30 +0,0 @@
-export type RectTuple = [number, number, number, number];
-export interface SerializedLayout {
-    rectangles: Record<string, RectTuple>;
-    totalHeight: number;
-    maxHeightReached: boolean;
-}
-export interface Rectangle<T> {
-    id: string;
-    l: number;
-    r: number;
-    top: number | null;
-    h: number;
-    originalHeight: number;
-    data?: T;
-    serializableData?: T;
-}
-export interface BaseLayout<T> {
-    addRect(id: string, left: number, right: number, height: number, data?: unknown, serializableData?: unknown, startingRow?: number): number | null;
-    collides(rect: Rectangle<T>, top: number): boolean;
-    addRectToBitmap(rect: Rectangle<T>, data: unknown): void;
-    getRectangles(): Map<string, RectTuple>;
-    discardRange(left: number, right: number): void;
-    serializeRegion(region: {
-        start: number;
-        end: number;
-    }): SerializedLayout;
-    getTotalHeight(): number;
-    maxHeightReached: boolean;
-    toJSON(): SerializedLayout;
-}

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

@@ -1,12 +0,0 @@
-import type { BaseLayout, SerializedLayout } from './BaseLayout.ts';
-export default class MultiLayout<SUB_LAYOUT_CLASS extends BaseLayout<T>, T> {
-    SubLayoutClass: new (...args: any[]) => SUB_LAYOUT_CLASS;
-    subLayoutConstructorArgs: Record<string, any>;
-    subLayouts: Map<string, SUB_LAYOUT_CLASS>;
-    constructor(SubLayoutClass: new (...args: any[]) => SUB_LAYOUT_CLASS, subLayoutConstructorArgs?: Record<string, any>);
-    getDataByID(id: string): unknown;
-    getSublayout(layoutName: string): SUB_LAYOUT_CLASS;
-    addRect(layoutName: string, id: string, left: number, right: number, height: number, data?: Record<string, T>, serializableData?: Record<string, T>): number | null;
-    discardRange(layoutName: string, left: number, right: number): void | undefined;
-    toJSON(): Record<string, SerializedLayout>;
-}

package/esm/util/layouts/MultiLayout.js

@@ -1,40 +0,0 @@
-export default class MultiLayout {
-    SubLayoutClass;
-    subLayoutConstructorArgs;
-    subLayouts = new Map();
-    constructor(SubLayoutClass, subLayoutConstructorArgs = {}) {
-        this.SubLayoutClass = SubLayoutClass;
-        this.subLayoutConstructorArgs = subLayoutConstructorArgs;
-    }
-    getDataByID(id) {
-        for (const layout of this.subLayouts.values()) {
-            const r = layout.getDataByID(id);
-            if (r) {
-                return r;
-            }
-        }
-        return undefined;
-    }
-    getSublayout(layoutName) {
-        let subLayout = this.subLayouts.get(layoutName);
-        if (subLayout === undefined) {
-            subLayout = new this.SubLayoutClass(this.subLayoutConstructorArgs);
-            this.subLayouts.set(layoutName, subLayout);
-            return subLayout;
-        }
-        return subLayout;
-    }
-    addRect(layoutName, id, left, right, height, data = {}, serializableData) {
-        return this.getSublayout(layoutName).addRect(id, left, right, height, data, serializableData);
-    }
-    discardRange(layoutName, left, right) {
-        return this.subLayouts.get(layoutName)?.discardRange(left, right);
-    }
-    toJSON() {
-        const data = {};
-        for (const [layoutName, sublayout] of this.subLayouts.entries()) {
-            data[layoutName] = sublayout.toJSON();
-        }
-        return data;
-    }
-}

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

@@ -1,41 +0,0 @@
-import type { BaseLayout, RectTuple, Rectangle, SerializedLayout } from './BaseLayout.ts';
-export interface PileupLayoutOptions {
-    featureHeight?: number;
-    spacing?: number;
-    maxHeight?: number;
-    padding?: number;
-}
-export interface PileupRectangle {
-    id: string;
-    left: number;
-    right: number;
-    top: number;
-}
-export default class PileupLayout<T> implements BaseLayout<T> {
-    private featureHeight;
-    private spacing;
-    private rowHeight;
-    private padding;
-    private maxRows;
-    private rows;
-    private rowMaxEnd;
-    private rectangles;
-    private lastLeft;
-    private lastRow;
-    maxHeightReached: boolean;
-    constructor(options?: PileupLayoutOptions);
-    addRect(id: string, left: number, right: number, height: number, data?: T, serializableData?: T): number | null;
-    private findFreeRow;
-    private addToRow;
-    collides(_rect: Rectangle<T>, _top: number): boolean;
-    addRectToBitmap(_rect: Rectangle<T>): void;
-    getTotalHeight(): number;
-    getRectangles(): Map<string, RectTuple>;
-    discardRange(left: number, right: number): void;
-    getDataByID(id: string): T | undefined;
-    serializeRegion(region: {
-        start: number;
-        end: number;
-    }): SerializedLayout;
-    toJSON(): SerializedLayout;
-}

package/esm/util/layouts/PileupLayout.js

@@ -1,202 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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.d.ts

@@ -1,31 +0,0 @@
-interface AbsoluteCache {
-    dirty: boolean;
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    width?: number;
-    height?: number;
-}
-export default class SceneGraph {
-    name: string;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    data?: Record<string, any> | undefined;
-    private children;
-    private absoluteCache;
-    parent?: SceneGraph;
-    constructor(name: string, left: number, top: number, width: number, height: number, data?: Record<string, any> | undefined);
-    addChild(nameOrSceneGraph: string | SceneGraph, left: number, top: number, width: number, height: number, data?: Record<string, any>): SceneGraph;
-    getSubRecord(name: string): SceneGraph | undefined;
-    expand(newLeft: number, newRight: number, newTop: number, newBottom: number): void;
-    get bottom(): number;
-    get right(): number;
-    walkParents(callback: (arg: SceneGraph) => void): void;
-    walkChildren(callback: (c: SceneGraph) => void): void;
-    get absolute(): AbsoluteCache;
-    move(x: number, y: number): void;
-}
-export {};