@jbrowse/core 3.6.5 → 4.0.0

package/util/Base1DViewModel.d.ts

@@ -1,61 +0,0 @@
-import type { BpOffset } from './Base1DUtils';
-import type { Feature } from './simpleFeature';
-import type { Region as IRegion } from './types';
-import type { Instance } from 'mobx-state-tree';
-declare const Base1DView: import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    displayedRegions: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<IRegion[], IRegion[], IRegion[]>, [undefined]>;
-    bpPerPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    offsetPx: import("mobx-state-tree").IType<number | undefined, number, number>;
-    interRegionPaddingWidth: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
-    minimumBlockWidth: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
-}, {
-    features: undefined | Feature[];
-    volatileWidth: number;
-} & {
-    setDisplayedRegions(regions: IRegion[]): void;
-    setBpPerPx(val: number): void;
-    setVolatileWidth(width: number): void;
-} & {
-    readonly width: number;
-    readonly assemblyNames: string[];
-    readonly displayedRegionsTotalPx: number;
-    readonly maxOffset: number;
-    readonly minOffset: number;
-    readonly totalBp: number;
-} & {
-    readonly dynamicBlocks: import("./blockTypes").BlockSet;
-    readonly staticBlocks: import("./blockTypes").BlockSet;
-    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, }: {
-        refName: string;
-        coord: number;
-        regionNumber?: number;
-    }): number | undefined;
-} & {
-    setFeatures(features: Feature[]): void;
-    showAllRegions(): void;
-    zoomOut(): void;
-    zoomIn(): void;
-    zoomTo(bpPerPx: number, offset?: number): number;
-    scrollTo(offsetPx: number): number;
-    centerAt(coord: number, refName: string | undefined, regionNumber: number): void;
-    scroll(distance: number): number;
-} & {
-    moveTo(start?: BpOffset, end?: BpOffset): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
-export type Base1DViewStateModel = typeof Base1DView;
-export type Base1DViewModel = Instance<Base1DViewStateModel>;
-export default Base1DView;

package/util/Base1DViewModel.js

@@ -1,135 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mobx_state_tree_1 = require("mobx-state-tree");
-const Base1DUtils_1 = require("./Base1DUtils");
-const calculateDynamicBlocks_1 = __importDefault(require("./calculateDynamicBlocks"));
-const calculateStaticBlocks_1 = __importDefault(require("./calculateStaticBlocks"));
-const index_1 = require("./index");
-const mst_1 = require("./types/mst");
-function x() { }
-const Base1DView = mobx_state_tree_1.types
-    .model('Base1DView', {
-    id: mst_1.ElementId,
-    displayedRegions: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.frozen(), []),
-    bpPerPx: 0,
-    offsetPx: 0,
-    interRegionPaddingWidth: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.number, 0),
-    minimumBlockWidth: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.number, 0),
-})
-    .volatile(() => ({
-    features: undefined,
-    volatileWidth: 0,
-}))
-    .actions(self => ({
-    setDisplayedRegions(regions) {
-        self.displayedRegions = (0, mobx_state_tree_1.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 (0, index_1.sum)(self.displayedRegions.map(a => a.end - a.start));
-    },
-}))
-    .views(self => ({
-    get dynamicBlocks() {
-        return (0, calculateDynamicBlocks_1.default)(self);
-    },
-    get staticBlocks() {
-        return (0, calculateStaticBlocks_1.default)(self);
-    },
-    get currBp() {
-        return (0, index_1.sum)(this.dynamicBlocks.map(a => a.end - a.start));
-    },
-}))
-    .views(self => ({
-    pxToBp(px) {
-        return (0, Base1DUtils_1.pxToBp)(self, px);
-    },
-    bpToPx({ refName, coord, regionNumber, }) {
-        var _a;
-        return (_a = (0, Base1DUtils_1.bpToPx)({ refName, coord, regionNumber, self })) === null || _a === void 0 ? void 0 : _a.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 = (0, index_1.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 = (0, index_1.clamp)(Math.round(((self.offsetPx + offset) * oldBpPerPx) / newBpPerPx - offset), self.minOffset, self.maxOffset);
-        return self.bpPerPx;
-    },
-    scrollTo(offsetPx) {
-        const newOffsetPx = (0, index_1.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 = (0, index_1.clamp)(self.offsetPx + distance, self.minOffset, self.maxOffset);
-        self.offsetPx = newOffsetPx;
-        return newOffsetPx - oldOffsetPx;
-    },
-}))
-    .actions(self => ({
-    moveTo(start, end) {
-        (0, Base1DUtils_1.moveTo)(self, start, end);
-    },
-}));
-exports.default = Base1DView;

package/util/QuickLRU.d.ts

@@ -1,32 +0,0 @@
-export default class QuickLRU extends Map<any, any> {
-    constructor(options?: {});
-    maxSize: any;
-    maxAge: any;
-    onEviction: any;
-    cache: Map<any, any>;
-    oldCache: Map<any, any>;
-    _size: number;
-    _emitEvictions(cache: any): void;
-    _deleteIfExpired(key: any, item: any): boolean;
-    _getOrDeleteIfExpired(key: any, item: any): any;
-    _getItemValue(key: any, item: any): any;
-    _peek(key: any, cache: any): any;
-    _set(key: any, value: any): void;
-    _moveToRecent(key: any, item: any): void;
-    _entriesAscending(): Generator<[any, any], void, unknown>;
-    get(key: any): any;
-    set(key: any, value: any, { maxAge }?: {
-        maxAge?: any;
-    }): void;
-    has(key: any): boolean;
-    peek(key: any): any;
-    delete(key: any): boolean;
-    resize(newSize: any): void;
-    keys(): Generator<any, void, unknown>;
-    values(): Generator<any, void, unknown>;
-    entriesDescending(): Generator<any[], void, unknown>;
-    entriesAscending(): Generator<any[], void, unknown>;
-    entries(): Generator<any[], void, unknown>;
-    forEach(callbackFunction: any, thisArgument?: this): void;
-    [Symbol.iterator](): Generator<any[], void, unknown>;
-}

package/util/QuickLRU.js

@@ -1,237 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class QuickLRU extends Map {
-    constructor(options = {}) {
-        super();
-        if (!(options.maxSize && options.maxSize > 0)) {
-            throw new TypeError('`maxSize` must be a number greater than 0');
-        }
-        if (typeof options.maxAge === 'number' && options.maxAge === 0) {
-            throw new TypeError('`maxAge` must be a number greater than 0');
-        }
-        this.maxSize = options.maxSize;
-        this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
-        this.onEviction = options.onEviction;
-        this.cache = new Map();
-        this.oldCache = new Map();
-        this._size = 0;
-    }
-    _emitEvictions(cache) {
-        if (typeof this.onEviction !== 'function') {
-            return;
-        }
-        for (const [key, item] of cache) {
-            this.onEviction(key, item.value);
-        }
-    }
-    _deleteIfExpired(key, item) {
-        if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
-            if (typeof this.onEviction === 'function') {
-                this.onEviction(key, item.value);
-            }
-            return this.delete(key);
-        }
-        return false;
-    }
-    _getOrDeleteIfExpired(key, item) {
-        const deleted = this._deleteIfExpired(key, item);
-        if (!deleted) {
-            return item.value;
-        }
-    }
-    _getItemValue(key, item) {
-        return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
-    }
-    _peek(key, cache) {
-        const item = cache.get(key);
-        return this._getItemValue(key, item);
-    }
-    _set(key, value) {
-        this.cache.set(key, value);
-        this._size++;
-        if (this._size >= this.maxSize) {
-            this._size = 0;
-            this._emitEvictions(this.oldCache);
-            this.oldCache = this.cache;
-            this.cache = new Map();
-        }
-    }
-    _moveToRecent(key, item) {
-        this.oldCache.delete(key);
-        this._set(key, item);
-    }
-    *_entriesAscending() {
-        for (const item of this.oldCache) {
-            const [key, value] = item;
-            if (!this.cache.has(key)) {
-                const deleted = this._deleteIfExpired(key, value);
-                if (!deleted) {
-                    yield item;
-                }
-            }
-        }
-        for (const item of this.cache) {
-            const [key, value] = item;
-            const deleted = this._deleteIfExpired(key, value);
-            if (!deleted) {
-                yield item;
-            }
-        }
-    }
-    get(key) {
-        if (this.cache.has(key)) {
-            const item = this.cache.get(key);
-            return this._getItemValue(key, item);
-        }
-        if (this.oldCache.has(key)) {
-            const item = this.oldCache.get(key);
-            if (!this._deleteIfExpired(key, item)) {
-                this._moveToRecent(key, item);
-                return item.value;
-            }
-        }
-    }
-    set(key, value, { maxAge = this.maxAge } = {}) {
-        const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
-            ? Date.now() + maxAge
-            : undefined;
-        if (this.cache.has(key)) {
-            this.cache.set(key, {
-                value,
-                expiry,
-            });
-        }
-        else {
-            this._set(key, { value, expiry });
-        }
-    }
-    has(key) {
-        if (this.cache.has(key)) {
-            return !this._deleteIfExpired(key, this.cache.get(key));
-        }
-        if (this.oldCache.has(key)) {
-            return !this._deleteIfExpired(key, this.oldCache.get(key));
-        }
-        return false;
-    }
-    peek(key) {
-        if (this.cache.has(key)) {
-            return this._peek(key, this.cache);
-        }
-        if (this.oldCache.has(key)) {
-            return this._peek(key, this.oldCache);
-        }
-    }
-    delete(key) {
-        const deleted = this.cache.delete(key);
-        if (deleted) {
-            this._size--;
-        }
-        return this.oldCache.delete(key) || deleted;
-    }
-    clear() {
-        this.cache.clear();
-        this.oldCache.clear();
-        this._size = 0;
-    }
-    resize(newSize) {
-        if (!(newSize && newSize > 0)) {
-            throw new TypeError('`maxSize` must be a number greater than 0');
-        }
-        const items = [...this._entriesAscending()];
-        const removeCount = items.length - newSize;
-        if (removeCount < 0) {
-            this.cache = new Map(items);
-            this.oldCache = new Map();
-            this._size = items.length;
-        }
-        else {
-            if (removeCount > 0) {
-                this._emitEvictions(items.slice(0, removeCount));
-            }
-            this.oldCache = new Map(items.slice(removeCount));
-            this.cache = new Map();
-            this._size = 0;
-        }
-        this.maxSize = newSize;
-    }
-    *keys() {
-        for (const [key] of this) {
-            yield key;
-        }
-    }
-    *values() {
-        for (const [, value] of this) {
-            yield value;
-        }
-    }
-    *[Symbol.iterator]() {
-        for (const item of this.cache) {
-            const [key, value] = item;
-            const deleted = this._deleteIfExpired(key, value);
-            if (!deleted) {
-                yield [key, value.value];
-            }
-        }
-        for (const item of this.oldCache) {
-            const [key, value] = item;
-            if (!this.cache.has(key)) {
-                const deleted = this._deleteIfExpired(key, value);
-                if (!deleted) {
-                    yield [key, value.value];
-                }
-            }
-        }
-    }
-    *entriesDescending() {
-        let items = [...this.cache];
-        for (let i = items.length - 1; i >= 0; --i) {
-            const item = items[i];
-            const [key, value] = item;
-            const deleted = this._deleteIfExpired(key, value);
-            if (!deleted) {
-                yield [key, value.value];
-            }
-        }
-        items = [...this.oldCache];
-        for (let i = items.length - 1; i >= 0; --i) {
-            const item = items[i];
-            const [key, value] = item;
-            if (!this.cache.has(key)) {
-                const deleted = this._deleteIfExpired(key, value);
-                if (!deleted) {
-                    yield [key, value.value];
-                }
-            }
-        }
-    }
-    *entriesAscending() {
-        for (const [key, value] of this._entriesAscending()) {
-            yield [key, value.value];
-        }
-    }
-    get size() {
-        if (!this._size) {
-            return this.oldCache.size;
-        }
-        let oldCacheSize = 0;
-        for (const key of this.oldCache.keys()) {
-            if (!this.cache.has(key)) {
-                oldCacheSize++;
-            }
-        }
-        return Math.min(this._size + oldCacheSize, this.maxSize);
-    }
-    entries() {
-        return this.entriesAscending();
-    }
-    forEach(callbackFunction, thisArgument = this) {
-        for (const [key, value] of this.entriesAscending()) {
-            callbackFunction.call(thisArgument, value, key, this);
-        }
-    }
-    get [Symbol.toStringTag]() {
-        return JSON.stringify([...this.entriesAscending()]);
-    }
-}
-exports.default = QuickLRU;

package/util/TimeTraveller.d.ts

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

package/util/TimeTraveller.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mobx_state_tree_1 = require("mobx-state-tree");
-const MAX_HISTORY_LENGTH = 20;
-function debounce(func, timeout = 300) {
-    let timer;
-    return (...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-            func(...args);
-        }, timeout);
-    };
-}
-const TimeTraveller = mobx_state_tree_1.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;
-    return {
-        stopTrackingUndo() {
-            self.notTrackingUndo = true;
-        },
-        resumeTrackingUndo() {
-            self.notTrackingUndo = false;
-        },
-        addUndoState(todos) {
-            if (self.notTrackingUndo) {
-                return;
-            }
-            if (skipNextUndoState) {
-                skipNextUndoState = false;
-                return;
-            }
-            self.history.splice(self.undoIdx + 1);
-            self.history.push(todos);
-            if (self.history.length > MAX_HISTORY_LENGTH) {
-                self.history.shift();
-            }
-            self.undoIdx = self.history.length - 1;
-        },
-        beforeDestroy() {
-            snapshotDisposer();
-        },
-        initialize() {
-            targetStore = self.targetPath
-                ? (0, mobx_state_tree_1.resolvePath)(self, self.targetPath)
-                : (0, mobx_state_tree_1.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 = (0, mobx_state_tree_1.onSnapshot)(targetStore, debounce((snapshot) => {
-                this.addUndoState(snapshot);
-            }, 300));
-            if (self.history.length === 0) {
-                this.addUndoState((0, mobx_state_tree_1.getSnapshot)(targetStore));
-            }
-        },
-        undo() {
-            self.undoIdx--;
-            skipNextUndoState = true;
-            if (targetStore) {
-                (0, mobx_state_tree_1.applySnapshot)(targetStore, self.history[self.undoIdx]);
-            }
-        },
-        redo() {
-            self.undoIdx++;
-            skipNextUndoState = true;
-            if (targetStore) {
-                (0, mobx_state_tree_1.applySnapshot)(targetStore, self.history[self.undoIdx]);
-            }
-        },
-    };
-});
-exports.default = TimeTraveller;

package/util/aborting.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAbortSignal = checkAbortSignal;
-exports.abortBreakPoint = abortBreakPoint;
-exports.makeAbortError = makeAbortError;
-exports.observeAbortSignal = observeAbortSignal;
-exports.isAbortException = isAbortException;
-const rxjs_1 = require("rxjs");
-class AbortError extends Error {
-}
-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));
-}
-async function abortBreakPoint(signal) {
-    await timeout(1);
-    checkAbortSignal(signal);
-}
-function makeAbortError() {
-    if (typeof DOMException !== 'undefined') {
-        return new DOMException('aborted', 'AbortError');
-    }
-    const e = new AbortError('aborted');
-    e.code = 'ERR_ABORTED';
-    return e;
-}
-function observeAbortSignal(signal) {
-    if (!signal) {
-        return new rxjs_1.Observable();
-    }
-    return (0, rxjs_1.fromEvent)(signal, 'abort');
-}
-function isAbortException(exception) {
-    return (exception instanceof Error &&
-        (exception.name === 'AbortError' ||
-            exception.code === 'ERR_ABORTED' ||
-            !!/\b(aborted|aborterror)\b/i.test(exception.message)));
-}