@jbrowse/core 3.6.5 → 4.0.0

package/esm/util/stats.js

@@ -0,0 +1,72 @@
+import { firstValueFrom } from 'rxjs';
+import { reduce } from 'rxjs/operators';
+export function calcStdFromSums(sum, sumSquares, n, population = false) {
+    if (n === 0) {
+        return 0;
+    }
+    let variance;
+    if (population) {
+        variance = sumSquares / n - (sum * sum) / (n * n);
+    }
+    else {
+        variance = sumSquares - (sum * sum) / n;
+        if (n > 1) {
+            variance /= n - 1;
+        }
+    }
+    return variance < 0 ? 0 : Math.sqrt(variance);
+}
+export function rectifyStats(s) {
+    return {
+        ...s,
+        scoreMean: (s.scoreSum || 0) / (s.featureCount || s.basesCovered || 1),
+        scoreStdDev: calcStdFromSums(s.scoreSum, s.scoreSumSquares, s.featureCount || s.basesCovered),
+        featureDensity: (s.featureCount || 1) / s.basesCovered,
+    };
+}
+export async function scoresToStats(region, feats) {
+    const { start, end } = region;
+    const seed = {
+        scoreMin: Number.MAX_VALUE,
+        scoreMax: Number.MIN_VALUE,
+        scoreSum: 0,
+        scoreSumSquares: 0,
+        featureCount: 0,
+    };
+    let found = false;
+    const { scoreMin, scoreMax, scoreSum, scoreSumSquares, featureCount } = await firstValueFrom(feats.pipe(reduce((acc, f) => {
+        const s = f.get('score');
+        const summary = f.get('summary');
+        const { scoreMax, scoreMin } = acc;
+        acc.scoreMax = Math.max(scoreMax, summary ? f.get('maxScore') : s);
+        acc.scoreMin = Math.min(scoreMin, summary ? f.get('minScore') : s);
+        acc.scoreSum += s;
+        acc.scoreSumSquares += s * s;
+        acc.featureCount += 1;
+        found = true;
+        return acc;
+    }, seed)));
+    return found
+        ? rectifyStats({
+            scoreMax,
+            scoreMin,
+            scoreSum,
+            scoreSumSquares,
+            featureCount,
+            basesCovered: end - start + 1,
+        })
+        : blankStats();
+}
+export function blankStats() {
+    return {
+        scoreMin: 0,
+        scoreMax: 0,
+        scoreMean: 0,
+        scoreStdDev: 0,
+        scoreSum: 0,
+        scoreSumSquares: 0,
+        featureCount: 0,
+        featureDensity: 0,
+        basesCovered: 0,
+    };
+}

package/esm/util/stopToken.d.ts

@@ -0,0 +1,19 @@
+export type StopToken = string;
+export declare function createStopTokenChecker(stopToken: StopToken | undefined): {
+    time: number;
+    iters: number;
+    stopToken: string | undefined;
+};
+export declare function createStopToken(): StopToken;
+export declare function stopStopToken(stopToken?: StopToken): void;
+export declare function checkStopToken(stopToken: StopToken | undefined): void;
+export interface LastStopTokenCheck {
+    time: number;
+    iters: number;
+    backoff?: boolean;
+    checkInterval?: number;
+    checkIters?: number;
+    stopToken?: StopToken;
+}
+export declare function checkStopToken2(lastCheck?: LastStopTokenCheck): void;
+export declare function forEachWithStopTokenCheck<T>(iter: Iterable<T>, stopToken: StopToken | undefined, arg: (arg: T, idx: number) => void, durationMs?: number, checkIters?: number, backoff?: boolean): void;

package/esm/util/stopToken.js

@@ -0,0 +1,90 @@
+import { isWebWorker } from "./isWebWorker.js";
+export function createStopTokenChecker(stopToken) {
+    return {
+        time: Date.now(),
+        iters: 0,
+        stopToken,
+    };
+}
+export function createStopToken() {
+    return URL.createObjectURL?.(new Blob()) || `${Math.random()}`;
+}
+function isSharedArrayBuffer(value) {
+    try {
+        return (typeof SharedArrayBuffer !== 'undefined' &&
+            value instanceof SharedArrayBuffer);
+    }
+    catch {
+        return false;
+    }
+}
+export function stopStopToken(stopToken) {
+    if (stopToken !== undefined) {
+        if (isSharedArrayBuffer(stopToken)) {
+            Atomics.store(new Int32Array(stopToken), 0, 1);
+        }
+        else {
+            URL.revokeObjectURL?.(stopToken);
+        }
+    }
+}
+export function checkStopToken(stopToken) {
+    if (stopToken === undefined) {
+        return;
+    }
+    if (isSharedArrayBuffer(stopToken)) {
+        if (Atomics.load(new Int32Array(stopToken), 0) === 1) {
+            throw new Error('aborted');
+        }
+    }
+    else if (typeof jest === 'undefined' && isWebWorker()) {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', stopToken, false);
+        try {
+            xhr.send(null);
+        }
+        catch {
+            throw new Error('aborted');
+        }
+    }
+}
+export function checkStopToken2(lastCheck) {
+    if (!lastCheck) {
+        return;
+    }
+    const { stopToken, backoff = true, checkInterval = 50, checkIters = 100, } = lastCheck;
+    lastCheck.iters++;
+    if (stopToken === undefined) {
+        return;
+    }
+    if (lastCheck.iters % checkIters !== 0) {
+        return;
+    }
+    if (isSharedArrayBuffer(stopToken)) {
+        checkStopToken(stopToken);
+    }
+    const now = Date.now();
+    if (now - lastCheck.time > checkInterval) {
+        lastCheck.time = now;
+        checkStopToken(stopToken);
+        if (backoff) {
+            lastCheck.checkInterval ??= checkInterval;
+            lastCheck.checkInterval += checkInterval;
+        }
+    }
+}
+export function forEachWithStopTokenCheck(iter, stopToken, arg, durationMs = 400, checkIters = 100, backoff = true) {
+    const lastCheck = {
+        time: Date.now(),
+        iters: 0,
+        checkInterval: durationMs,
+        backoff,
+        checkIters,
+        stopToken,
+    };
+    let iters = 0;
+    for (const t of iter) {
+        arg(t, iters++);
+        checkStopToken2(lastCheck);
+    }
+}

package/esm/util/tracks.d.ts

@@ -0,0 +1,72 @@
+import type { FileLocation, PreFileLocation } from './types/index.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { IAnyStateTreeNode, IAnyType, Instance, types } from '@jbrowse/mobx-state-tree';
+export declare function getTrackAssemblyNames(track: IAnyStateTreeNode & {
+    configuration: AnyConfigurationModel;
+}): string[];
+export declare function getConfAssemblyNames(conf: AnyConfigurationModel): string[];
+export declare function getRpcSessionId(thisNode: IAnyStateTreeNode): string;
+export declare function getParentRenderProps(node: IAnyStateTreeNode): any;
+export declare const UNKNOWN = "UNKNOWN";
+export declare const UNSUPPORTED = "UNSUPPORTED";
+export declare function getBlob(id: string): File | undefined;
+export declare function getBlobMap(): Record<string, File>;
+export declare function setBlobMap(map: Record<string, File>): void;
+export declare function storeBlobLocation(location: PreFileLocation): import("./index.ts").PreUriLocation | import("./index.ts").PreLocalPathLocation | {
+    name: string;
+    blobId: string;
+    locationType: string;
+};
+export declare function makeIndex(location: FileLocation, suffix: string): import("./index.ts").BlobLocation | {
+    uri: string;
+    locationType: string;
+    localPath?: undefined;
+} | {
+    localPath: string;
+    locationType: string;
+    uri?: undefined;
+};
+export declare function makeIndexType(name: string | undefined, typeA: string, typeB: string): string;
+export interface AdapterConfig {
+    type: string;
+    [key: string]: unknown;
+}
+export type AdapterGuesser = (file: FileLocation, index?: FileLocation, adapterHint?: string) => AdapterConfig | undefined;
+export type TrackTypeGuesser = (adapterName: string) => string | undefined;
+export declare function getFileName(track: FileLocation): string;
+export declare function guessAdapter(file: FileLocation, index: FileLocation | undefined, adapterHint?: string, model?: IAnyStateTreeNode): AdapterConfig;
+export declare function guessTrackType(adapterType: string, model?: IAnyStateTreeNode): string;
+export declare function generateUnsupportedTrackConf(trackName: string, trackUrl: string, categories: string[] | undefined): {
+    type: string;
+    name: string;
+    description: string;
+    category: string[] | undefined;
+    trackId: string;
+};
+export declare function generateUnknownTrackConf(trackName: string, trackUrl: string, categories?: string[]): {
+    type: string;
+    name: string;
+    description: string;
+    category: string[] | undefined;
+    trackId: string;
+};
+export declare function getTrackName(conf: AnyConfigurationModel | {
+    name?: string;
+    type?: string;
+}, session: {
+    assemblies: AnyConfigurationModel[];
+}): string;
+type MSTArray<T extends IAnyType> = Instance<ReturnType<typeof types.array<T>>>;
+interface MinimalTrack extends IAnyType {
+    configuration: {
+        trackId: string;
+    };
+}
+interface GenericView {
+    type: string;
+    tracks: MSTArray<MinimalTrack>;
+}
+export declare function showTrackGeneric(self: GenericView, trackId: string, initialSnapshot?: {}, displayInitialSnapshot?: {}): any;
+export declare function hideTrackGeneric(self: GenericView, trackId: string): 0 | 1;
+export declare function toggleTrackGeneric(self: GenericView, trackId: string): void;
+export {};

package/esm/util/tracks.js

@@ -0,0 +1,214 @@
+import { getParent, isRoot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { getEnv, getSession, objectHash } from "./index.js";
+import { readConfObject } from "../configuration/index.js";
+const trackAssemblyNamesCache = new WeakMap();
+export function getTrackAssemblyNames(track) {
+    let cached = trackAssemblyNamesCache.get(track);
+    if (!cached) {
+        cached = getConfAssemblyNames(track.configuration);
+        trackAssemblyNamesCache.set(track, cached);
+    }
+    return cached;
+}
+export function getConfAssemblyNames(conf) {
+    const trackAssemblyNames = readConfObject(conf, 'assemblyNames');
+    if (!trackAssemblyNames) {
+        const parent = getParent(conf);
+        if ('sequence' in parent) {
+            return [readConfObject(parent, 'name')];
+        }
+        else {
+            throw new Error('unknown assembly names');
+        }
+    }
+    return trackAssemblyNames;
+}
+export function getRpcSessionId(thisNode) {
+    let highestRpcSessionId;
+    for (let node = thisNode; !isRoot(node); node = getParent(node)) {
+        if ('rpcSessionId' in node) {
+            highestRpcSessionId = node.rpcSessionId;
+        }
+    }
+    if (!highestRpcSessionId) {
+        throw new Error('getRpcSessionId failed, no parent node in the state tree has an `rpcSessionId` attribute');
+    }
+    return highestRpcSessionId;
+}
+export function getParentRenderProps(node) {
+    for (let currentNode = getParent(node); !isRoot(currentNode); currentNode = getParent(currentNode)) {
+        if ('renderProps' in currentNode) {
+            return currentNode.renderProps();
+        }
+    }
+    return {};
+}
+export const UNKNOWN = 'UNKNOWN';
+export const UNSUPPORTED = 'UNSUPPORTED';
+let blobMap = {};
+export function getBlob(id) {
+    return blobMap[id];
+}
+export function getBlobMap() {
+    return blobMap;
+}
+export function setBlobMap(map) {
+    blobMap = map;
+}
+let counter = 0;
+export function storeBlobLocation(location) {
+    if ('blob' in location) {
+        const blobId = `b${Date.now()}-${counter++}`;
+        blobMap[blobId] = location.blob;
+        return { name: location.blob.name, blobId, locationType: 'BlobLocation' };
+    }
+    return location;
+}
+export function makeIndex(location, suffix) {
+    if ('uri' in location) {
+        return {
+            uri: location.uri + suffix,
+            locationType: 'UriLocation',
+        };
+    }
+    else if ('localPath' in location) {
+        return {
+            localPath: location.localPath + suffix,
+            locationType: 'LocalPathLocation',
+        };
+    }
+    else {
+        return location;
+    }
+}
+export function makeIndexType(name, typeA, typeB) {
+    return name?.toUpperCase().endsWith(typeA) ? typeA : typeB;
+}
+export function getFileName(track) {
+    const uri = 'uri' in track ? track.uri : undefined;
+    const localPath = 'localPath' in track ? track.localPath : undefined;
+    const blob = 'blobId' in track ? track : undefined;
+    return (blob?.name ||
+        uri?.slice(uri.lastIndexOf('/') + 1) ||
+        localPath?.slice(localPath.replace(/\\/g, '/').lastIndexOf('/') + 1) ||
+        '');
+}
+export function guessAdapter(file, index, adapterHint, model) {
+    if (model) {
+        const { pluginManager } = getEnv(model);
+        const adapterGuesser = pluginManager.evaluateExtensionPoint('Core-guessAdapterForLocation', (_file, _index, _adapterHint) => {
+            return undefined;
+        });
+        const adapter = adapterGuesser(file, index, adapterHint);
+        if (adapter) {
+            return adapter;
+        }
+    }
+    return {
+        type: UNKNOWN,
+    };
+}
+export function guessTrackType(adapterType, model) {
+    if (model) {
+        const session = getSession(model);
+        const trackTypeGuesser = getEnv(session).pluginManager.evaluateExtensionPoint('Core-guessTrackTypeForLocation', (_adapterName) => {
+            return undefined;
+        });
+        const trackType = trackTypeGuesser(adapterType);
+        if (trackType) {
+            return trackType;
+        }
+    }
+    return 'FeatureTrack';
+}
+export function generateUnsupportedTrackConf(trackName, trackUrl, categories) {
+    const conf = {
+        type: 'FeatureTrack',
+        name: `${trackName} (Unsupported)`,
+        description: `Support not yet implemented for "${trackUrl}"`,
+        category: categories,
+        trackId: '',
+    };
+    conf.trackId = objectHash(conf);
+    return conf;
+}
+export function generateUnknownTrackConf(trackName, trackUrl, categories) {
+    const conf = {
+        type: 'FeatureTrack',
+        name: `${trackName} (Unknown)`,
+        description: `Could not determine track type for "${trackUrl}"`,
+        category: categories,
+        trackId: '',
+    };
+    conf.trackId = objectHash(conf);
+    return conf;
+}
+export function getTrackName(conf, session) {
+    const trackName = isStateTreeNode(conf)
+        ? readConfObject(conf, 'name')
+        : (conf.name ?? '');
+    const trackType = isStateTreeNode(conf)
+        ? readConfObject(conf, 'type')
+        : conf.type;
+    if (!trackName && trackType === 'ReferenceSequenceTrack') {
+        const asm = session.assemblies.find(a => a.sequence === conf);
+        return asm
+            ? `Reference sequence (${readConfObject(asm, 'displayName') || readConfObject(asm, 'name')})`
+            : 'Reference sequence';
+    }
+    return trackName;
+}
+export function showTrackGeneric(self, trackId, initialSnapshot = {}, displayInitialSnapshot = {}) {
+    const { pluginManager } = getEnv(self);
+    const session = getSession(self);
+    const found = self.tracks.find(t => t.configuration.trackId === trackId);
+    if (found) {
+        return found;
+    }
+    const conf = session.tracksById[trackId];
+    if (!conf) {
+        throw new Error(`Could not resolve identifier "${trackId}"`);
+    }
+    const trackType = pluginManager.getTrackType(conf.type);
+    if (!trackType) {
+        throw new Error(`Unknown track type ${conf.type}`);
+    }
+    const viewType = pluginManager.getViewType(self.type);
+    const supportedDisplays = new Set(viewType.displayTypes.map(d => d.name));
+    const displays = conf.displays ?? [];
+    const displayConf = displays.find((d) => supportedDisplays.has(d.type));
+    const displayType = displayConf?.type ??
+        trackType.displayTypes.find(d => supportedDisplays.has(d.name))?.name;
+    if (!displayType) {
+        throw new Error(`Could not find a compatible display for view type ${self.type}`);
+    }
+    const displayId = displayConf?.displayId ?? `${trackId}-${displayType}`;
+    const track = trackType.stateModel.create({
+        ...initialSnapshot,
+        type: conf.type,
+        configuration: trackId,
+        displays: [
+            {
+                type: displayType,
+                configuration: displayId,
+                ...displayInitialSnapshot,
+            },
+        ],
+    });
+    self.tracks.push(track);
+    return track;
+}
+export function hideTrackGeneric(self, trackId) {
+    const t = self.tracks.find(t => t.configuration.trackId === trackId);
+    if (t) {
+        self.tracks.remove(t);
+        return 1;
+    }
+    return 0;
+}
+export function toggleTrackGeneric(self, trackId) {
+    const hiddenCount = hideTrackGeneric(self, trackId);
+    if (!hiddenCount) {
+        showTrackGeneric(self, trackId);
+    }
+}

package/esm/util/transferables.d.ts

@@ -0,0 +1,2 @@
+export declare function isDetachedBuffer(buffer: ArrayBufferLike): boolean;
+export declare function collectTransferables(result: Record<string, unknown>): Transferable[];

package/esm/util/transferables.js

@@ -0,0 +1,35 @@
+export function isDetachedBuffer(buffer) {
+    return buffer.byteLength === 0;
+}
+function isImageBitmap(value) {
+    return typeof ImageBitmap !== 'undefined' && value instanceof ImageBitmap;
+}
+function isArrayBufferLike(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof value.byteLength === 'number');
+}
+export function collectTransferables(result) {
+    const transferables = [];
+    const { imageData, flatbush, subfeatureFlatbush } = result;
+    if (isImageBitmap(imageData)) {
+        transferables.push(imageData);
+    }
+    if (isArrayBufferLike(flatbush)) {
+        if (isDetachedBuffer(flatbush)) {
+            console.warn('flatbush buffer is already detached, cannot transfer');
+        }
+        else {
+            transferables.push(flatbush);
+        }
+    }
+    if (isArrayBufferLike(subfeatureFlatbush)) {
+        if (isDetachedBuffer(subfeatureFlatbush)) {
+            console.warn('subfeatureFlatbush buffer is already detached, cannot transfer');
+        }
+        else {
+            transferables.push(subfeatureFlatbush);
+        }
+    }
+    return transferables;
+}

package/esm/util/tss-react/cssAndCx.d.ts

@@ -0,0 +1,16 @@
+import type { Css, Cx } from './types.ts';
+import type { EmotionCache } from '@emotion/cache';
+export declare const createCssAndCx: (params: {
+    cache: EmotionCache;
+}) => {
+    css: Css;
+    cx: Cx;
+};
+export declare function createUseCssAndCx(params: {
+    useCache: () => EmotionCache;
+}): {
+    useCssAndCx: () => {
+        css: Css;
+        cx: Cx;
+    };
+};

package/esm/util/tss-react/cssAndCx.js

@@ -0,0 +1,97 @@
+import { useMemo } from 'react';
+import { serializeStyles } from '@emotion/serialize';
+import { getRegisteredStyles, insertStyles } from '@emotion/utils';
+import { classnames } from "./tools/classnames.js";
+import { matchCSSObject } from "./types.js";
+export const { createCssAndCx } = (() => {
+    function merge(registered, css, className) {
+        const registeredStyles = [];
+        const rawClassName = getRegisteredStyles(registered, registeredStyles, className);
+        if (registeredStyles.length < 2) {
+            return className;
+        }
+        return rawClassName + css(registeredStyles);
+    }
+    function createCssAndCx(params) {
+        const { cache } = params;
+        const css = (...args) => {
+            const serialized = serializeStyles(args, cache.registered);
+            insertStyles(cache, serialized, false);
+            const className = `${cache.key}-${serialized.name}`;
+            scope: {
+                const arg = args[0];
+                if (!matchCSSObject(arg)) {
+                    break scope;
+                }
+                increaseSpecificityToTakePrecedenceOverMediaQueries.saveClassNameCSSObjectMapping(cache, className, arg);
+            }
+            return className;
+        };
+        const cx = (...args) => {
+            const className = classnames(args);
+            const feat27FixedClassnames = increaseSpecificityToTakePrecedenceOverMediaQueries.fixClassName(cache, className, css);
+            return merge(cache.registered, css, feat27FixedClassnames);
+        };
+        return { css, cx };
+    }
+    return { createCssAndCx };
+})();
+export function createUseCssAndCx(params) {
+    const { useCache } = params;
+    function useCssAndCx() {
+        const cache = useCache();
+        const { css, cx } = useMemo(() => createCssAndCx({ cache }), [cache]);
+        return { css, cx };
+    }
+    return { useCssAndCx };
+}
+const increaseSpecificityToTakePrecedenceOverMediaQueries = (() => {
+    const cssObjectMapByCache = new WeakMap();
+    return {
+        saveClassNameCSSObjectMapping: (cache, className, cssObject) => {
+            let cssObjectMap = cssObjectMapByCache.get(cache);
+            if (cssObjectMap === undefined) {
+                cssObjectMap = new Map();
+                cssObjectMapByCache.set(cache, cssObjectMap);
+            }
+            cssObjectMap.set(className, cssObject);
+        },
+        fixClassName: (() => {
+            function fix(classNameCSSObjects) {
+                let isThereAnyMediaQueriesInPreviousClasses = false;
+                return classNameCSSObjects.map(([className, cssObject]) => {
+                    if (cssObject === undefined) {
+                        return className;
+                    }
+                    let out;
+                    if (!isThereAnyMediaQueriesInPreviousClasses) {
+                        out = className;
+                        for (const key in cssObject) {
+                            if (key.startsWith('@media')) {
+                                isThereAnyMediaQueriesInPreviousClasses = true;
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        out = {
+                            '&&': cssObject,
+                        };
+                    }
+                    return out;
+                });
+            }
+            return (cache, className, css) => {
+                if (!className.includes(' ')) {
+                    return className;
+                }
+                const cssObjectMap = cssObjectMapByCache.get(cache);
+                return classnames(fix(className
+                    .split(' ')
+                    .map(className => [className, cssObjectMap?.get(className)])).map(classNameOrCSSObject => typeof classNameOrCSSObject === 'string'
+                    ? classNameOrCSSObject
+                    : css(classNameOrCSSObject)));
+            };
+        })(),
+    };
+})();

package/esm/util/tss-react/index.d.ts

@@ -0,0 +1,4 @@
+export { keyframes } from '@emotion/react';
+export { makeStyles } from './mui/index.ts';
+import { type CxArg } from './tools/classnames.ts';
+export declare function cx(...args: CxArg[]): string;

package/esm/util/tss-react/index.js

@@ -0,0 +1,7 @@
+'use client';
+export { keyframes } from '@emotion/react';
+export { makeStyles } from "./mui/index.js";
+import { classnames } from "./tools/classnames.js";
+export function cx(...args) {
+    return classnames(args);
+}

package/esm/util/tss-react/makeStyles.d.ts

@@ -0,0 +1,15 @@
+import type { CSSObject } from './types.ts';
+export declare function createMakeStyles<Theme>(params: {
+    useTheme: () => Theme;
+}): {
+    makeStyles: () => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: ((theme: Theme) => Record<RuleName, CSSObject>) | Record<RuleName, CSSObject>) => (_params?: unknown, muiStyleOverridesParams?: {
+        props: {
+            classes?: Record<string, string>;
+        };
+    }) => {
+        classes: Record<RuleName, string>;
+        theme: Theme;
+        css: import("./types.ts").Css;
+        cx: import("./types.ts").Cx;
+    };
+};