@jbrowse/core 3.6.5 → 4.0.0

package/esm/util/Base1DViewModel.js

@@ -0,0 +1,129 @@
+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() { }
+const Base1DView = types
+    .model('Base1DView', {
+    id: ElementId,
+    displayedRegions: types.optional(types.frozen(), []),
+    bpPerPx: 0,
+    offsetPx: 0,
+    interRegionPaddingWidth: types.optional(types.number, 0),
+    minimumBlockWidth: types.optional(types.number, 0),
+})
+    .volatile(() => ({
+    features: undefined,
+    volatileWidth: 0,
+}))
+    .actions(self => ({
+    setDisplayedRegions(regions) {
+        self.displayedRegions = cast(regions);
+    },
+    setBpPerPx(val) {
+        self.bpPerPx = val;
+    },
+    setVolatileWidth(width) {
+        self.volatileWidth = width;
+    },
+}))
+    .views(self => ({
+    get width() {
+        return self.volatileWidth;
+    },
+    get assemblyNames() {
+        return [...new Set(self.displayedRegions.map(r => r.assemblyName))];
+    },
+    get displayedRegionsTotalPx() {
+        return this.totalBp / self.bpPerPx;
+    },
+    get maxOffset() {
+        const leftPadding = 10;
+        return this.displayedRegionsTotalPx - leftPadding;
+    },
+    get minOffset() {
+        const rightPadding = 30;
+        return -this.width + rightPadding;
+    },
+    get totalBp() {
+        return sum(self.displayedRegions.map(a => a.end - a.start));
+    },
+}))
+    .views(self => ({
+    get dynamicBlocks() {
+        return calculateDynamicBlocks(self);
+    },
+    get staticBlocks() {
+        return calculateStaticBlocks(self);
+    },
+    get currBp() {
+        return sum(this.dynamicBlocks.map(a => a.end - a.start));
+    },
+}))
+    .views(self => ({
+    pxToBp(px) {
+        return pxToBp(self, px);
+    },
+    bpToPx({ refName, coord, regionNumber, }) {
+        return bpToPx({ refName, coord, regionNumber, self })?.offsetPx;
+    },
+}))
+    .actions(self => ({
+    setFeatures(features) {
+        self.features = features;
+    },
+    showAllRegions() {
+        self.bpPerPx = self.totalBp / self.width;
+        self.offsetPx = 0;
+    },
+    zoomOut() {
+        this.zoomTo(self.bpPerPx * 2);
+    },
+    zoomIn() {
+        this.zoomTo(self.bpPerPx / 2);
+    },
+    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 oldBpPerPx = self.bpPerPx;
+        if (Math.abs(oldBpPerPx - newBpPerPx) < 0.000001) {
+            return oldBpPerPx;
+        }
+        self.bpPerPx = newBpPerPx;
+        self.offsetPx = clamp(Math.round(((self.offsetPx + offset) * oldBpPerPx) / newBpPerPx - offset), self.minOffset, self.maxOffset);
+        return self.bpPerPx;
+    },
+    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));
+        }
+    },
+    scroll(distance) {
+        const oldOffsetPx = self.offsetPx;
+        const newOffsetPx = clamp(self.offsetPx + distance, self.minOffset, self.maxOffset);
+        self.offsetPx = newOffsetPx;
+        return newOffsetPx - oldOffsetPx;
+    },
+}))
+    .actions(self => ({
+    moveTo(start, end) {
+        moveTo(self, start, end);
+    },
+}));
+export default Base1DView;

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

@@ -0,0 +1 @@
+export { default } from '@jbrowse/quick-lru';

package/esm/util/QuickLRU/index.js

@@ -0,0 +1 @@
+export { default } from '@jbrowse/quick-lru';

package/esm/util/TimeTraveller.d.ts

@@ -0,0 +1,19 @@
+declare const TimeTraveller: import("@jbrowse/mobx-state-tree").IModelType<{
+    undoIdx: import("@jbrowse/mobx-state-tree").IType<number | undefined, number, number>;
+    targetPath: import("@jbrowse/mobx-state-tree").IType<string | undefined, string, string>;
+}, {
+    history: unknown[];
+    notTrackingUndo: boolean;
+} & {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+} & {
+    stopTrackingUndo(): void;
+    resumeTrackingUndo(): void;
+    addUndoState(snapshot: unknown): void;
+    beforeDestroy(): void;
+    initialize(): void;
+    undo(): void;
+    redo(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export default TimeTraveller;

package/esm/util/TimeTraveller.js

@@ -0,0 +1,94 @@
+import { applySnapshot, getEnv, getSnapshot, onSnapshot, resolvePath, types, } from '@jbrowse/mobx-state-tree';
+const MAX_HISTORY_LENGTH = 20;
+const TimeTraveller = types
+    .model('TimeTraveller', {
+    undoIdx: -1,
+    targetPath: '',
+})
+    .volatile(() => ({
+    history: [],
+    notTrackingUndo: false,
+}))
+    .views(self => ({
+    get canUndo() {
+        return self.undoIdx > 0 && !self.notTrackingUndo;
+    },
+    get canRedo() {
+        return self.undoIdx < self.history.length - 1 && !self.notTrackingUndo;
+    },
+}))
+    .actions(self => {
+    let targetStore;
+    let snapshotDisposer;
+    let skipNextUndoState = false;
+    let debounceTimer;
+    let pendingSnapshot;
+    return {
+        stopTrackingUndo() {
+            self.notTrackingUndo = true;
+        },
+        resumeTrackingUndo() {
+            self.notTrackingUndo = false;
+        },
+        addUndoState(snapshot) {
+            if (self.notTrackingUndo) {
+                return;
+            }
+            if (skipNextUndoState) {
+                skipNextUndoState = false;
+                return;
+            }
+            self.history.splice(self.undoIdx + 1);
+            self.history.push(snapshot);
+            if (self.history.length > MAX_HISTORY_LENGTH) {
+                self.history.shift();
+            }
+            self.undoIdx = self.history.length - 1;
+        },
+        beforeDestroy() {
+            snapshotDisposer();
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+        },
+        initialize() {
+            targetStore = self.targetPath
+                ? resolvePath(self, self.targetPath)
+                : getEnv(self).targetStore;
+            if (!targetStore) {
+                throw new Error('Failed to find target store for TimeTraveller. Please provide `targetPath` property, or a `targetStore` in the environment');
+            }
+            snapshotDisposer = onSnapshot(targetStore, snapshot => {
+                if (self.notTrackingUndo || skipNextUndoState) {
+                    return;
+                }
+                pendingSnapshot = snapshot;
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                }
+                debounceTimer = setTimeout(() => {
+                    debounceTimer = undefined;
+                    this.addUndoState(pendingSnapshot);
+                }, 300);
+            });
+            if (self.history.length === 0) {
+                this.addUndoState(getSnapshot(targetStore));
+            }
+        },
+        undo() {
+            self.undoIdx--;
+            skipNextUndoState = true;
+            if (targetStore) {
+                applySnapshot(targetStore, self.history[self.undoIdx]);
+            }
+        },
+        redo() {
+            self.undoIdx++;
+            skipNextUndoState = true;
+            if (targetStore) {
+                applySnapshot(targetStore, self.history[self.undoIdx]);
+            }
+        },
+    };
+});
+export default TimeTraveller;

package/esm/util/aborting.js

@@ -0,0 +1,42 @@
+import { Observable, fromEvent } from 'rxjs';
+class AbortError extends Error {
+    code;
+}
+export function checkAbortSignal(signal) {
+    if (!signal) {
+        return;
+    }
+    if (!(signal instanceof AbortSignal)) {
+        throw new TypeError('must pass an AbortSignal');
+    }
+    if (signal.aborted) {
+        throw makeAbortError();
+    }
+}
+function timeout(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function abortBreakPoint(signal) {
+    await timeout(1);
+    checkAbortSignal(signal);
+}
+export function makeAbortError() {
+    if (typeof DOMException !== 'undefined') {
+        return new DOMException('aborted', 'AbortError');
+    }
+    const e = new AbortError('aborted');
+    e.code = 'ERR_ABORTED';
+    return e;
+}
+export function observeAbortSignal(signal) {
+    if (!signal) {
+        return new Observable();
+    }
+    return fromEvent(signal, 'abort');
+}
+export function isAbortException(exception) {
+    return (exception instanceof Error &&
+        (exception.name === 'AbortError' ||
+            exception.code === 'ERR_ABORTED' ||
+            /\b(aborted|aborterror)\b/i.test(exception.message)));
+}

package/esm/util/analytics.js

@@ -0,0 +1,80 @@
+import { readConfObject } from "../configuration/index.js";
+import { isElectron } from "../util/index.js";
+export async function writeAWSAnalytics(rootModel, initialTimeStamp, sessionQuery) {
+    try {
+        const url = 'https://analytics.jbrowse.org/api/v1';
+        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter((track) => (readConfObject(track, 'assemblyNames') || []).length > 1).length;
+        const savedSessionCount = Object.keys(localStorage).filter(name => name.includes('localSaved-')).length;
+        const { jbrowse: config, session, version: ver } = rootModel;
+        const { tracks, assemblies, plugins } = config;
+        const stats = {
+            ver,
+            'plugins-count': plugins?.length || 0,
+            'plugin-names': plugins?.map((p) => p.name).join(','),
+            'assemblies-count': assemblies.length,
+            'tracks-count': tracks.length,
+            'session-tracks-count': session?.sessionTracks.length || 0,
+            'open-views': session?.views.length || 0,
+            'synteny-tracks-count': multiAssemblyTracks,
+            'saved-sessions-count': savedSessionCount,
+            'existing-session-param-type': sessionQuery?.split('-')[0] || 'none',
+            'scn-h': window.screen.height,
+            'scn-w': window.screen.width,
+            'win-h': window.innerHeight,
+            'win-w': window.innerWidth,
+            electron: isElectron,
+            loadTime: (Date.now() - initialTimeStamp) / 1000,
+            jb2: true,
+        };
+        tracks.forEach((track) => {
+            const key = `track-types-${track.type}`;
+            stats[key] = stats[key] + 1 || 1;
+        });
+        session?.sessionTracks.forEach((track) => {
+            const key = `sessionTrack-types-${track.type}`;
+            stats[key] = stats[key] + 1 || 1;
+        });
+        const qs = Object.keys(stats)
+            .map(key => `${key}=${stats[key]}`)
+            .join('&');
+        await fetch(`${url}?${qs}`);
+    }
+    catch (e) {
+        console.error('Failed to write analytics to AWS.', e);
+    }
+}
+export async function writeGAAnalytics(rootModel, initialTimestamp) {
+    const jbrowseUser = 'UA-7115575-5';
+    const stats = {
+        'tracks-count': rootModel.jbrowse.tracks.length,
+        ver: rootModel.version,
+        electron: isElectron,
+        loadTime: Date.now() - initialTimestamp,
+        pluginNames: rootModel.jbrowse.plugins?.map((plugin) => plugin.name) || '',
+    };
+    let analyticsScript = "(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){";
+    analyticsScript +=
+        '(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),';
+    analyticsScript +=
+        'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)';
+    analyticsScript +=
+        "})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');";
+    analyticsScript += `ga('create', '${jbrowseUser}', 'auto', 'jbrowseTracker');`;
+    const gaData = {};
+    const googleDimensions = 'tracks-count ver electron loadTime pluginNames';
+    for (const [index, key] of googleDimensions.split(/\s+/).entries()) {
+        gaData[`dimension${index + 1}`] = stats[key];
+    }
+    gaData.metric1 = Math.round(stats.loadTime);
+    analyticsScript += `ga('jbrowseTracker.send', 'pageview',${JSON.stringify(gaData)});`;
+    const analyticsScriptNode = document.createElement('script');
+    analyticsScriptNode.innerHTML = analyticsScript;
+    document.getElementsByTagName('head')[0].append(analyticsScriptNode);
+}
+export function doAnalytics(rootModel, initialTimestamp, initialSessionQuery) {
+    if (rootModel &&
+        !readConfObject(rootModel.jbrowse.configuration, 'disableAnalytics')) {
+        writeAWSAnalytics(rootModel, initialTimestamp, initialSessionQuery);
+        writeGAAnalytics(rootModel, initialTimestamp);
+    }
+}

package/esm/util/blobToDataURL.js

@@ -0,0 +1,14 @@
+export function blobToDataURL(blob) {
+    const a = new FileReader();
+    return new Promise((resolve, reject) => {
+        a.onload = e => {
+            if (e.target) {
+                resolve(e.target.result);
+            }
+            else {
+                reject(new Error('unknown result reading blob from canvas'));
+            }
+        };
+        a.readAsDataURL(blob);
+    });
+}

package/esm/util/blockTypes.d.ts

@@ -0,0 +1,59 @@
+type Func<T> = (value: BaseBlock, index: number, array: BaseBlock[]) => T;
+export declare class BlockSet {
+    blocks: BaseBlock[];
+    constructor(blocks?: BaseBlock[]);
+    [Symbol.iterator](): Generator<BaseBlock, void, unknown>;
+    push(block: BaseBlock): void;
+    getBlocks(): BaseBlock[];
+    getRegions(): {
+        refName: string;
+        start: number;
+        end: number;
+        assemblyName: string;
+        reversed: boolean | undefined;
+    }[];
+    map<T, U = this>(func: Func<T>, thisarg?: U): T[];
+    forEach<T, U = this>(func: Func<T>, thisarg?: U): void;
+    get length(): number;
+    get totalWidthPx(): number;
+    get totalWidthPxWithoutBorders(): number;
+    get offsetPx(): number;
+    get contentBlocks(): BaseBlock[];
+    get totalBp(): number;
+}
+export declare class BaseBlock {
+    type: string;
+    regionNumber?: number;
+    reversed?: boolean;
+    refName: string;
+    start: number;
+    end: number;
+    assemblyName: string;
+    key: string;
+    offsetPx: number;
+    widthPx: number;
+    variant?: string;
+    isLeftEndOfDisplayedRegion?: boolean;
+    constructor(data: Record<string, any>);
+    toRegion(): {
+        refName: string;
+        start: number;
+        end: number;
+        assemblyName: string;
+        reversed: boolean | undefined;
+    };
+}
+export declare class ContentBlock extends BaseBlock {
+    type: string;
+}
+export declare class ElidedBlock extends BaseBlock {
+    type: string;
+    widthPx: number;
+    elidedBlockCount: number;
+    constructor(data: Record<string, any>);
+    push(otherBlock: ElidedBlock): void;
+}
+export declare class InterRegionPaddingBlock extends BaseBlock {
+    type: string;
+}
+export {};

package/esm/util/blockTypes.js

@@ -0,0 +1,119 @@
+export class BlockSet {
+    blocks;
+    constructor(blocks = []) {
+        this.blocks = blocks;
+    }
+    *[Symbol.iterator]() {
+        yield* this.blocks;
+    }
+    push(block) {
+        if (block.type === 'ElidedBlock' && this.blocks.length > 0) {
+            const lastBlock = this.blocks.at(-1);
+            if (lastBlock?.type === 'ElidedBlock') {
+                ;
+                lastBlock.push(block);
+                return;
+            }
+        }
+        this.blocks.push(block);
+    }
+    getBlocks() {
+        return this.blocks;
+    }
+    getRegions() {
+        return this.blocks.map(block => block.toRegion());
+    }
+    map(func, thisarg) {
+        return this.blocks.map(func, thisarg);
+    }
+    forEach(func, thisarg) {
+        this.blocks.forEach(func, thisarg);
+    }
+    get length() {
+        return this.blocks.length;
+    }
+    get totalWidthPx() {
+        let total = 0;
+        for (let i = 0, l = this.blocks.length; i < l; i++) {
+            total += this.blocks[i].widthPx;
+        }
+        return total;
+    }
+    get totalWidthPxWithoutBorders() {
+        let total = 0;
+        for (let i = 0, l = this.blocks.length; i < l; i++) {
+            if (this.blocks[i].variant !== 'boundary') {
+                total += this.blocks[i].widthPx;
+            }
+        }
+        return total;
+    }
+    get offsetPx() {
+        return this.blocks.length > 0 ? this.blocks[0].offsetPx : 0;
+    }
+    get contentBlocks() {
+        return this.blocks.filter(block => block.type === 'ContentBlock');
+    }
+    get totalBp() {
+        let total = 0;
+        for (let i = 0, l = this.contentBlocks.length; i < l; i++) {
+            const b = this.contentBlocks[i];
+            total += b.end - b.start;
+        }
+        return total;
+    }
+}
+export class BaseBlock {
+    type = 'BaseBlock';
+    regionNumber;
+    reversed;
+    refName;
+    start;
+    end;
+    assemblyName;
+    key;
+    offsetPx;
+    widthPx = 0;
+    variant;
+    isLeftEndOfDisplayedRegion;
+    constructor(data) {
+        Object.assign(this, data);
+        this.assemblyName = data.assemblyName;
+        this.refName = data.refName;
+        this.start = data.start;
+        this.end = data.end;
+        this.key = data.key;
+        this.offsetPx = data.offsetPx;
+    }
+    toRegion() {
+        return {
+            refName: this.refName,
+            start: this.start,
+            end: this.end,
+            assemblyName: this.assemblyName,
+            reversed: this.reversed,
+        };
+    }
+}
+export class ContentBlock extends BaseBlock {
+    type = 'ContentBlock';
+}
+export class ElidedBlock extends BaseBlock {
+    type = 'ElidedBlock';
+    widthPx;
+    elidedBlockCount = 0;
+    constructor(data) {
+        super(data);
+        this.widthPx = data.widthPx;
+    }
+    push(otherBlock) {
+        this.elidedBlockCount += 1;
+        this.refName = '';
+        this.start = 0;
+        this.end = 0;
+        this.widthPx += otherBlock.widthPx;
+    }
+}
+export class InterRegionPaddingBlock extends BaseBlock {
+    type = 'InterRegionPaddingBlock';
+}

package/esm/util/calculateDynamicBlocks.d.ts

@@ -0,0 +1,3 @@
+import { BlockSet } from './blockTypes.ts';
+import type { Base1DViewModel } from './calculateStaticBlocks.ts';
+export default function calculateDynamicBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean): BlockSet;

package/esm/util/calculateDynamicBlocks.js

@@ -0,0 +1,104 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { BlockSet, ContentBlock, ElidedBlock, InterRegionPaddingBlock, } from "./blockTypes.js";
+import { assembleLocStringFast } from "./index.js";
+import { intersection2 } from "./range.js";
+export default function calculateDynamicBlocks(model, padding = true, elision = true) {
+    const { offsetPx, displayedRegions, bpPerPx, width, minimumBlockWidth, interRegionPaddingWidth, } = model;
+    if (!width) {
+        throw new Error('view has no width, cannot calculate displayed blocks');
+    }
+    const invBpPerPx = 1 / bpPerPx;
+    const blocks = new BlockSet();
+    let displayedRegionLeftPx = 0;
+    const windowLeftPx = offsetPx;
+    const windowRightPx = windowLeftPx + width;
+    for (let regionNumber = 0; regionNumber < displayedRegions.length; regionNumber++) {
+        const region = displayedRegions[regionNumber];
+        const { assemblyName, refName, start: regionStart, end: regionEnd, reversed, } = region;
+        const displayedRegionRightPx = displayedRegionLeftPx + (regionEnd - regionStart) * invBpPerPx;
+        const regionWidthPx = (regionEnd - regionStart) * invBpPerPx;
+        const parentRegion = isStateTreeNode(region) ? getSnapshot(region) : region;
+        const [leftPx, rightPx] = intersection2(windowLeftPx, windowRightPx, displayedRegionLeftPx, displayedRegionRightPx);
+        if (leftPx !== undefined && rightPx !== undefined) {
+            let start;
+            let end;
+            let isLeftEndOfDisplayedRegion;
+            let isRightEndOfDisplayedRegion;
+            let blockOffsetPx;
+            if (reversed) {
+                start = Math.max(regionStart, regionEnd - (rightPx - displayedRegionLeftPx) * bpPerPx);
+                end = regionEnd - (leftPx - displayedRegionLeftPx) * bpPerPx;
+                isLeftEndOfDisplayedRegion = end === regionEnd;
+                isRightEndOfDisplayedRegion = start === regionStart;
+                blockOffsetPx = displayedRegionLeftPx + (regionEnd - end) * invBpPerPx;
+            }
+            else {
+                start = (leftPx - displayedRegionLeftPx) * bpPerPx + regionStart;
+                end = Math.min(regionEnd, (rightPx - displayedRegionLeftPx) * bpPerPx + regionStart);
+                isLeftEndOfDisplayedRegion = start === regionStart;
+                isRightEndOfDisplayedRegion = end === regionEnd;
+                blockOffsetPx =
+                    displayedRegionLeftPx + (start - regionStart) * invBpPerPx;
+            }
+            const widthPx = (end - start) * invBpPerPx;
+            const blockData = {
+                assemblyName,
+                refName,
+                start,
+                end,
+                reversed,
+                offsetPx: blockOffsetPx,
+                parentRegion,
+                regionNumber,
+                widthPx,
+                isLeftEndOfDisplayedRegion,
+                isRightEndOfDisplayedRegion,
+                key: `${assembleLocStringFast({
+                    assemblyName,
+                    refName,
+                    start,
+                    end,
+                    reversed,
+                })}-${regionNumber}${reversed ? '-reversed' : ''}`,
+            };
+            if (padding && blocks.length === 0 && isLeftEndOfDisplayedRegion) {
+                blocks.push(new InterRegionPaddingBlock({
+                    key: `${blockData.key}-beforeFirstRegion`,
+                    widthPx: -offsetPx,
+                    offsetPx: blockData.offsetPx + offsetPx,
+                    variant: 'boundary',
+                }));
+            }
+            if (elision && regionWidthPx < minimumBlockWidth) {
+                blocks.push(new ElidedBlock(blockData));
+            }
+            else {
+                blocks.push(new ContentBlock(blockData));
+            }
+            if (padding) {
+                if (regionWidthPx >= minimumBlockWidth &&
+                    blockData.isRightEndOfDisplayedRegion &&
+                    regionNumber < displayedRegions.length - 1) {
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-rightpad`,
+                        widthPx: interRegionPaddingWidth,
+                        offsetPx: blockData.offsetPx + blockData.widthPx,
+                    }));
+                    displayedRegionLeftPx += interRegionPaddingWidth;
+                }
+                if (regionNumber === displayedRegions.length - 1 &&
+                    blockData.isRightEndOfDisplayedRegion) {
+                    blockOffsetPx = blockData.offsetPx + blockData.widthPx;
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-afterLastRegion`,
+                        widthPx: width - blockOffsetPx + offsetPx,
+                        offsetPx: blockOffsetPx,
+                        variant: 'boundary',
+                    }));
+                }
+            }
+        }
+        displayedRegionLeftPx += (regionEnd - regionStart) * invBpPerPx;
+    }
+    return blocks;
+}

package/esm/util/calculateStaticBlocks.d.ts

@@ -0,0 +1,13 @@
+import { BlockSet } from './blockTypes.ts';
+import type { Region } from './types/index.ts';
+import type { Region as RegionModel } from './types/mst.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export interface Base1DViewModel {
+    offsetPx: number;
+    width: number;
+    displayedRegions: (Region | Instance<typeof RegionModel>)[];
+    bpPerPx: number;
+    minimumBlockWidth: number;
+    interRegionPaddingWidth: number;
+}
+export default function calculateStaticBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean, extra?: number, width?: number): BlockSet;