@jbrowse/core 3.7.0 → 4.0.0

package/esm/util/io/RemoteFileWithRangeCache.js

@@ -0,0 +1,71 @@
+import { HttpRangeFetcher } from '@gmod/http-range-fetcher';
+import { RemoteFile } from 'generic-filehandle2';
+const fetchers = {};
+function binaryRangeFetch(url, start, end, options = {}) {
+    const fetcher = fetchers[url];
+    if (!fetcher) {
+        throw new Error(`fetch not registered for ${url}`);
+    }
+    return fetcher(url, start, end, options);
+}
+const globalRangeCache = new HttpRangeFetcher({
+    fetch: binaryRangeFetch,
+    size: 500 * 1024 ** 2,
+    chunkSize: 128 * 1024,
+    maxFetchSize: 100 * 1024 ** 2,
+    minimumTTL: 24 * 60 * 60 * 1000,
+});
+export function clearCache() {
+    globalRangeCache.reset();
+}
+export class RemoteFileWithRangeCache extends RemoteFile {
+    async fetch(url, init) {
+        const str = String(url);
+        if (!fetchers[str]) {
+            fetchers[str] = this.fetchBinaryRange.bind(this);
+        }
+        const range = new Headers(init?.headers).get('range');
+        if (range) {
+            const rangeParse = /bytes=(\d+)-(\d+)/.exec(range);
+            if (rangeParse) {
+                const [, start, end] = rangeParse;
+                const s = Number.parseInt(start, 10);
+                const e = Number.parseInt(end, 10);
+                const len = e - s;
+                const { buffer, headers } = (await globalRangeCache.getRange(`${url}`, s, len + 1));
+                return new Response(buffer, {
+                    status: 206,
+                    headers,
+                });
+            }
+        }
+        return super.fetch(url, init);
+    }
+    async fetchBinaryRange(url, start, end, options = {}) {
+        const requestDate = new Date();
+        const res = await super.fetch(url, {
+            ...options,
+            headers: {
+                ...options.headers,
+                range: `bytes=${start}-${end}`,
+            },
+        });
+        const responseDate = new Date();
+        if (!res.ok) {
+            const errorMessage = `HTTP ${res.status} fetching ${url} bytes ${start}-${end}`;
+            const hint = ' (should be 206 for range requests)';
+            throw new Error(`${errorMessage}${res.status === 200 ? hint : ''}`);
+        }
+        const headers = {};
+        for (const [k, v] of res.headers.entries()) {
+            headers[k] = v;
+        }
+        const arrayBuffer = await res.arrayBuffer();
+        return {
+            headers,
+            requestDate,
+            responseDate,
+            buffer: new Uint8Array(arrayBuffer),
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+import type PluginManager from '../../PluginManager.ts';
+import type { FileLocation, UriLocation } from '../types/index.ts';
+import type { Fetcher, GenericFilehandle } from 'generic-filehandle2';
+export declare function resolveUriLocation(location: UriLocation): UriLocation;
+export declare function openLocation(location: FileLocation, pluginManager?: PluginManager): GenericFilehandle;
+export declare function getFetcher(location: FileLocation, pluginManager?: PluginManager): Fetcher;
+export { RemoteFileWithRangeCache } from './RemoteFileWithRangeCache.ts';

package/esm/util/io/index.js

@@ -0,0 +1,92 @@
+import isNode from 'detect-node';
+import { BlobFile, LocalFile } from 'generic-filehandle2';
+import { RemoteFileWithRangeCache } from "./RemoteFileWithRangeCache.js";
+import { isElectron } from "../index.js";
+import { getBlob } from "../tracks.js";
+import { AuthNeededError, isRootModelWithInternetAccounts, isUriLocation, } from "../types/index.js";
+function isLocalPathLocation(location) {
+    return 'localPath' in location;
+}
+function isBlobLocation(location) {
+    return 'blobId' in location;
+}
+export function resolveUriLocation(location) {
+    return location.baseUri
+        ? { ...location, uri: new URL(location.uri, location.baseUri).href }
+        : location;
+}
+export function openLocation(location, pluginManager) {
+    if (isLocalPathLocation(location)) {
+        if (!location.localPath) {
+            throw new Error('No local path provided');
+        }
+        if (isNode || isElectron) {
+            return new LocalFile(location.localPath);
+        }
+        else {
+            throw new Error("can't use local files in the browser");
+        }
+    }
+    if (isBlobLocation(location)) {
+        const blob = getBlob(location.blobId);
+        if (!blob) {
+            throw new Error(`file ("${location.name}") was opened locally from a previous session. To restore it, go to track settings and reopen the file`);
+        }
+        return new BlobFile(blob);
+    }
+    if (isUriLocation(location)) {
+        if (!location.uri) {
+            throw new Error('No URI provided');
+        }
+        const absoluteLocation = resolveUriLocation(location);
+        if (pluginManager) {
+            const internetAccount = getInternetAccount(location, pluginManager);
+            if (internetAccount) {
+                return internetAccount.openLocation(absoluteLocation);
+            }
+        }
+        return new RemoteFileWithRangeCache(absoluteLocation.uri, {
+            fetch: checkAuthNeededFetch,
+        });
+    }
+    throw new Error('invalid fileLocation');
+}
+export function getFetcher(location, pluginManager) {
+    if (!isUriLocation(location)) {
+        throw new Error(`Not a valid UriLocation: ${JSON.stringify(location)}`);
+    }
+    if (pluginManager) {
+        const internetAccount = getInternetAccount(location, pluginManager);
+        if (internetAccount) {
+            return internetAccount.getFetcher(location);
+        }
+    }
+    return checkAuthNeededFetch;
+}
+function getInternetAccount(location, pluginManager) {
+    const { rootModel } = pluginManager;
+    if (rootModel && isRootModelWithInternetAccounts(rootModel)) {
+        return rootModel.findAppropriateInternetAccount(location);
+    }
+    if (location.internetAccountPreAuthorization) {
+        if (!location.internetAccountPreAuthorization.authInfo.token) {
+            throw new Error('Failed to obtain token from internet account. Try reloading the page');
+        }
+        return pluginManager
+            .getInternetAccountType(location.internetAccountPreAuthorization.internetAccountType)
+            .stateModel.create({
+            type: location.internetAccountPreAuthorization.internetAccountType,
+            configuration: location.internetAccountPreAuthorization.authInfo.configuration,
+        });
+    }
+    return undefined;
+}
+async function checkAuthNeededFetch(url, opts) {
+    const response = await fetch(url, opts);
+    if (response.status === 401 &&
+        response.headers.get('WWW-Authenticate')?.includes('Basic')) {
+        throw new AuthNeededError('Accessing HTTPBasic resource without authentication', url.toString());
+    }
+    return response;
+}
+export { RemoteFileWithRangeCache } from "./RemoteFileWithRangeCache.js";

package/esm/util/isWebWorker.d.ts

@@ -0,0 +1 @@
+export declare function isWebWorker(): boolean;

package/esm/util/isWebWorker.js

@@ -0,0 +1,4 @@
+export function isWebWorker() {
+    return (typeof WorkerGlobalScope !== 'undefined' &&
+        self instanceof WorkerGlobalScope);
+}

package/esm/util/jexl.d.ts

@@ -0,0 +1,2 @@
+import { Jexl } from '@jbrowse/jexl';
+export default function JexlF(): Jexl;

package/esm/util/jexl.js

@@ -0,0 +1,49 @@
+import { Jexl } from '@jbrowse/jexl';
+export default function JexlF() {
+    const j = new Jexl();
+    j.addFunction('get', (feature, data) => feature.get(data));
+    j.addFunction('parent', (feature) => feature.parent?.());
+    j.addFunction('id', (feature) => feature.id());
+    j.addFunction('cast', (arg) => arg);
+    j.addFunction('log', (thing) => {
+        console.log(thing);
+        return thing;
+    });
+    j.addFunction('max', Math.max);
+    j.addFunction('min', Math.min);
+    j.addFunction('sqrt', Math.sqrt);
+    j.addFunction('ceil', Math.ceil);
+    j.addFunction('floor', Math.floor);
+    j.addFunction('round', Math.round);
+    j.addFunction('abs', Math.abs);
+    j.addFunction('log10', Math.log10);
+    j.addFunction('parseInt', Number.parseInt);
+    j.addFunction('parseFloat', Number.parseFloat);
+    j.addFunction('split', (s, char) => s.split(char));
+    j.addFunction('join', (k, ...args) => [...args].filter(f => !!f).join(k));
+    j.addFunction('charAt', (s, index) => s.charAt(index));
+    j.addFunction('charCodeAt', (s, index) => s.charCodeAt(index));
+    j.addFunction('codePointAt', (s, pos) => s.codePointAt(pos));
+    j.addFunction('startsWith', (s, search, len) => s.startsWith(search, len));
+    j.addFunction('endsWith', (s, search, len) => s.endsWith(search, len));
+    j.addFunction('padEnd', (s, len, pad) => s.padEnd(len, pad));
+    j.addFunction('padStart', (s, len, fill) => s.padStart(len, fill));
+    j.addFunction('repeat', (s, count) => s.repeat(count));
+    j.addFunction('replace', (s, match, sub) => s.replace(match, sub));
+    j.addFunction('replaceAll', (s, match, sub) => s.replaceAll(match, sub));
+    j.addFunction('slice', (s, start, end) => s.slice(start, end));
+    j.addFunction('startsWith', (s, search, pos) => s.startsWith(search, pos));
+    j.addFunction('substring', (s, start, end) => s.substring(start, end));
+    j.addFunction('toLowerCase', (s) => s.toLowerCase());
+    j.addFunction('toUpperCase', (s) => s.toUpperCase());
+    j.addFunction('jsonParse', (s) => JSON.parse(s));
+    j.addFunction('trim', (s) => s.trim());
+    j.addFunction('trimEnd', (s) => s.trimEnd());
+    j.addFunction('trimStart', (s) => s.trimStart());
+    j.addFunction('getTag', (feature, s) => {
+        const tags = feature.get('tags');
+        return tags ? tags[s] : feature.get(s);
+    });
+    j.addBinaryOp('&', 15, (a, b) => a & b);
+    return j;
+}

package/esm/util/jexlStrings.js

@@ -0,0 +1,17 @@
+import createJexlInstance from "./jexl.js";
+const compilationCache = {};
+export function stringToJexlExpression(str, jexl) {
+    const cacheKey = `nosig|${str}`;
+    if (!compilationCache[cacheKey]) {
+        const match = str.startsWith('jexl:');
+        if (!match) {
+            throw new Error('string does not appear to be in jexl format');
+        }
+        const code = str.split('jexl:')[1];
+        const compiled = jexl
+            ? jexl.compile(code)
+            : createJexlInstance().compile(code);
+        compilationCache[cacheKey] = compiled;
+    }
+    return compilationCache[cacheKey];
+}

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

@@ -0,0 +1,30 @@
+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/BaseLayout.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,37 @@
+import type { BaseLayout, RectTuple, Rectangle, SerializedLayout } from './BaseLayout.ts';
+export default class GranularRectLayout<T> implements BaseLayout<T> {
+    private pitchX;
+    private pitchY;
+    private hardRowLimit;
+    private bitmap;
+    private rectangles;
+    maxHeightReached: boolean;
+    private maxHeight;
+    private displayMode;
+    private pTotalHeight;
+    constructor({ pitchX, pitchY, maxHeight, hardRowLimit, displayMode, }?: {
+        pitchX?: number;
+        pitchY?: number;
+        maxHeight?: number;
+        displayMode?: string;
+        hardRowLimit?: number;
+    });
+    addRect(id: string, left: number, right: number, height: number, data?: T, serializableData?: T, startingRow?: number): number | null;
+    collides(rect: Rectangle<T>, top: number): boolean;
+    addRectToBitmap(rect: Rectangle<T>): void;
+    discardRange(left: number, right: number): void;
+    hasSeen(id: string): boolean;
+    getByCoord(x: number, y: number): string | Record<string, T> | undefined;
+    getByID(id: string): RectTuple | undefined;
+    getDataByID(id: string): T | undefined;
+    getSerializableDataByID(id: string): T | undefined;
+    cleanup(): void;
+    getTotalHeight(): number;
+    get totalHeight(): number;
+    getRectangles(): Map<string, RectTuple>;
+    serializeRegion(region: {
+        start: number;
+        end: number;
+    }): SerializedLayout;
+    toJSON(): SerializedLayout;
+}