@jbrowse/core 3.7.0 → 4.0.1

package/esm/ReExports/modules.js

@@ -0,0 +1,149 @@
+import * as React from 'react';
+import * as mst from '@jbrowse/mobx-state-tree';
+import { alpha, createTheme, useTheme } from '@mui/material';
+import * as MUIStyles from '@mui/material/styles';
+import * as MUIUtils from '@mui/material/utils';
+import { useGridApiContext, useGridApiRef, useGridRootProps, } from '@mui/x-data-grid';
+import * as mobx from 'mobx';
+import * as mxreact from 'mobx-react';
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+import * as ReactDom from 'react-dom';
+import * as ReactDomClient from 'react-dom/client';
+import Plugin from "../Plugin.js";
+import { BaseFeatureDetail } from "./BaseFeatureDetails.js";
+import { DataGridEntries } from "./MuiDataGridReExports.js";
+import { Entries } from "./MuiReExports.js";
+import { lazyMap } from "./lazify.js";
+import reExportsList from "./list.js";
+import * as Configuration from "../configuration/index.js";
+import * as BaseAdapterExports from "../data_adapters/BaseAdapter/index.js";
+import AdapterType from "../pluggableElementTypes/AdapterType.js";
+import DisplayType from "../pluggableElementTypes/DisplayType.js";
+import TrackType from "../pluggableElementTypes/TrackType.js";
+import ViewType from "../pluggableElementTypes/ViewType.js";
+import WidgetType from "../pluggableElementTypes/WidgetType.js";
+import * as pluggableElementTypes from "../pluggableElementTypes/index.js";
+import * as pluggableElementTypeModels from "../pluggableElementTypes/models/index.js";
+import * as BoxRendererType from "../pluggableElementTypes/renderers/BoxRendererType.js";
+import CircularChordRendererType from "../pluggableElementTypes/renderers/CircularChordRendererType.js";
+import * as FeatureRendererType from "../pluggableElementTypes/renderers/FeatureRendererType.js";
+import * as RendererType from "../pluggableElementTypes/renderers/RendererType.js";
+import * as ServerSideRendererType from "../pluggableElementTypes/renderers/ServerSideRendererType.js";
+import * as coreUi from "../ui/index.js";
+import * as coreTheme from "../ui/theme.js";
+import Base1DView from "../util/Base1DViewModel.js";
+import * as coreColor from "../util/color/index.js";
+import * as coreUtil from "../util/index.js";
+import * as coreIo from "../util/io/index.js";
+import * as coreLayouts from "../util/layouts/index.js";
+import * as coreMstReflection from "../util/mst-reflection.js";
+import * as rxjs from "../util/rxjs.js";
+import * as trackUtils from "../util/tracks.js";
+import { cx, keyframes, makeStyles } from "../util/tss-react/index.js";
+import * as mstTypes from "../util/types/mst.js";
+const libs = {
+    mobx,
+    '@jbrowse/mobx-state-tree': mst,
+    'mobx-state-tree': mst,
+    react: React,
+    'react/jsx-runtime': ReactJSXRuntime,
+    'react-dom': ReactDom,
+    'react-dom/client': ReactDomClient,
+    'mobx-react': mxreact,
+    '@mui/x-data-grid': {
+        useGridApiContext,
+        useGridApiRef,
+        useGridRootProps,
+        ...lazyMap(DataGridEntries),
+    },
+    '@mui/material/utils': MUIUtils,
+    '@material-ui/core/utils': MUIUtils,
+    'tss-react': {
+        cx,
+        keyframes,
+        makeStyles,
+    },
+    'tss-react/mui': {
+        cx,
+        keyframes,
+        makeStyles,
+    },
+    '@material-ui/core': {
+        ...lazyMap(Entries),
+        useTheme,
+        alpha,
+        makeStyles: (args) => {
+            const useStyles = makeStyles()(args);
+            return () => useStyles().classes;
+        },
+    },
+    '@mui/material': {
+        ...lazyMap(Entries),
+        alpha,
+        useTheme,
+        createTheme,
+    },
+    ...lazyMap(Entries, '@mui/material/'),
+    ...lazyMap(Entries, '@material-ui/core/'),
+    '@mui/material/styles': {
+        ...MUIStyles,
+        makeStyles: (args) => {
+            const useStyles = makeStyles()(args);
+            return () => useStyles().classes;
+        },
+    },
+    '@material-ui/core/styles': {
+        ...MUIStyles,
+        makeStyles: (args) => {
+            const useStyles = makeStyles()(args);
+            return () => useStyles().classes;
+        },
+    },
+    '@material-ui/lab/ToggleButton': Entries.ToggleButton,
+    '@material-ui/lab/ToggleButtonGroup': Entries.ToggleButtonGroup,
+    '@material-ui/lab/Autocomplete': Entries.Autocomplete,
+    '@material-ui/lab/Alert': Entries.Alert,
+    '@material-ui/lab': {
+        Alert: Entries.Alert,
+        Autocomplete: Entries.Autocomplete,
+        ToggleButton: Entries.ToggleButton,
+        ToggleButtonGroup: Entries.ToggleButtonGroup,
+    },
+    '@jbrowse/core/Plugin': Plugin,
+    '@jbrowse/core/pluggableElementTypes/renderers/RendererType': RendererType,
+    '@jbrowse/core/configuration': Configuration,
+    '@jbrowse/core/util/types/mst': mstTypes,
+    '@jbrowse/core/ui': coreUi,
+    '@jbrowse/core/ui/theme': coreTheme,
+    '@jbrowse/core/util': coreUtil,
+    '@jbrowse/core/util/color': coreColor,
+    '@jbrowse/core/util/layouts': coreLayouts,
+    '@jbrowse/core/util/tracks': trackUtils,
+    '@jbrowse/core/util/Base1DViewModel': Base1DView,
+    '@jbrowse/core/util/io': coreIo,
+    '@jbrowse/core/util/mst-reflection': coreMstReflection,
+    '@jbrowse/core/util/rxjs': rxjs,
+    '@jbrowse/core/pluggableElementTypes': pluggableElementTypes,
+    '@jbrowse/core/pluggableElementTypes/ViewType': ViewType,
+    '@jbrowse/core/pluggableElementTypes/AdapterType': AdapterType,
+    '@jbrowse/core/pluggableElementTypes/DisplayType': DisplayType,
+    '@jbrowse/core/pluggableElementTypes/TrackType': TrackType,
+    '@jbrowse/core/pluggableElementTypes/WidgetType': WidgetType,
+    '@jbrowse/core/pluggableElementTypes/models': pluggableElementTypeModels,
+    '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType': ServerSideRendererType,
+    '@jbrowse/core/pluggableElementTypes/renderers/CircularChordRendererType': CircularChordRendererType,
+    '@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType': BoxRendererType,
+    '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType': FeatureRendererType,
+    '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail': BaseFeatureDetail,
+    '@jbrowse/core/data_adapters/BaseAdapter': BaseAdapterExports,
+};
+const libsList = Object.keys(libs);
+const inLibsOnly = libsList.filter(mod => !reExportsList.includes(mod));
+if (inLibsOnly.length > 0) {
+    throw new Error(`The following modules are in the modules libs, but not the re-exports list: ${inLibsOnly.join(', ')}`);
+}
+const inReExportsOnly = reExportsList.filter(mod => !libsList.includes(mod));
+if (inReExportsOnly.length) {
+    throw new Error(`The following modules are in the re-exports list, but not the modules libs: ${inReExportsOnly.join(', ')}`);
+}
+export default libs;

package/esm/TextSearch/BaseResults.d.ts

@@ -0,0 +1,46 @@
+import type React from 'react';
+import type { SearchType } from '../data_adapters/BaseAdapter/index.ts';
+import type TextSearchAdapterType from '../pluggableElementTypes/TextSearchAdapterType.ts';
+export interface BaseResultArgs {
+    label: string;
+    displayString?: string;
+    renderingComponent?: React.ReactElement;
+    matchedAttribute?: string;
+    matchedObject?: object;
+    textSearchAdapter?: TextSearchAdapterType;
+    relevance?: SearchType;
+    locString?: string;
+    refName?: string;
+    trackId?: string;
+    score?: number;
+    results?: BaseResult[];
+}
+export default class BaseResult {
+    label: string;
+    renderingComponent?: React.ReactElement;
+    displayString?: string;
+    matchedAttribute?: string;
+    matchedObject?: object;
+    textSearchAdapter?: TextSearchAdapterType;
+    relevance?: SearchType;
+    trackId?: string;
+    score: number;
+    locString?: string;
+    results?: BaseResult[];
+    constructor(args: BaseResultArgs);
+    getLabel(): string;
+    getDisplayString(): string;
+    getRenderingComponent(): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | undefined;
+    getTrackId(): string | undefined;
+    getScore(): number;
+    updateScore(newScore: number): number;
+    getId(): string;
+    hasLocation(): boolean;
+    getLocation(): string | undefined;
+    getComboResults(): BaseResult[] | undefined;
+}
+export declare class RefSequenceResult extends BaseResult {
+    refName: string;
+    constructor(args: BaseResultArgs);
+    getLocation(): string;
+}

package/esm/TextSearch/BaseResults.js

@@ -0,0 +1,67 @@
+export default class BaseResult {
+    label;
+    renderingComponent;
+    displayString;
+    matchedAttribute;
+    matchedObject;
+    textSearchAdapter;
+    relevance;
+    trackId;
+    score;
+    locString;
+    results;
+    constructor(args) {
+        this.label = args.label;
+        this.locString = args.locString;
+        this.renderingComponent = args.renderingComponent;
+        this.displayString = args.displayString;
+        this.matchedAttribute = args.matchedAttribute;
+        this.matchedObject = args.matchedObject;
+        this.textSearchAdapter = args.textSearchAdapter;
+        this.relevance = args.relevance;
+        this.trackId = args.trackId;
+        this.score = args.score || 1;
+        this.results = args.results || [];
+    }
+    getLabel() {
+        return this.label;
+    }
+    getDisplayString() {
+        return this.displayString || this.label;
+    }
+    getRenderingComponent() {
+        return this.renderingComponent;
+    }
+    getTrackId() {
+        return this.trackId;
+    }
+    getScore() {
+        return this.score;
+    }
+    updateScore(newScore) {
+        this.score = newScore;
+        return this.score;
+    }
+    getId() {
+        return `${this.getLabel()}-${this.getLocation()}-${this.getTrackId()}`;
+    }
+    hasLocation() {
+        return !!this.locString;
+    }
+    getLocation() {
+        return this.locString;
+    }
+    getComboResults() {
+        return this.results;
+    }
+}
+export class RefSequenceResult extends BaseResult {
+    refName;
+    constructor(args) {
+        super(args);
+        this.refName = args.refName ?? '';
+    }
+    getLocation() {
+        return this.refName;
+    }
+}

package/esm/TextSearch/TextSearchManager.d.ts

@@ -0,0 +1,48 @@
+import QuickLRU from '../util/QuickLRU/index.ts';
+import type BaseResult from './BaseResults.ts';
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '../data_adapters/BaseAdapter/index.ts';
+export interface SearchScope {
+    includeAggregateIndexes: boolean;
+    assemblyName: string;
+    tracks?: string[];
+}
+export default class TextSearchManager {
+    pluginManager: PluginManager;
+    adapterCache: QuickLRU<string, BaseTextSearchAdapter>;
+    constructor(pluginManager: PluginManager);
+    loadTextSearchAdapters(searchScope: SearchScope): Promise<BaseTextSearchAdapter[]>;
+    relevantAdapters(searchScope: SearchScope): ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+            [x: string]: any;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>);
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    getAdaptersWithAssembly(assemblyName: string, confs: AnyConfigurationModel[]): ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+            [x: string]: any;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>);
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    getTrackAdaptersWithAssembly(assemblyName: string, confs: AnyConfigurationModel[]): ({
+        [x: string]: any;
+    } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+            [x: string]: any;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & any & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>);
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    search(args: BaseTextSearchArgs, searchScope: SearchScope, rankFn: (results: BaseResult[]) => BaseResult[]): Promise<BaseResult[]>;
+    search2({ args, searchScope, rankFn, }: {
+        args: BaseTextSearchArgs;
+        searchScope: SearchScope;
+        rankFn: (results: BaseResult[]) => BaseResult[];
+    }): Promise<BaseResult[]>;
+    sortResults2({ results, rankFn, args, }: {
+        results: BaseResult[];
+        args: BaseTextSearchArgs;
+        rankFn: (results: BaseResult[]) => BaseResult[];
+    }): BaseResult[];
+}

package/esm/TextSearch/TextSearchManager.js

@@ -0,0 +1,77 @@
+import uFuzzy from '@leeoniya/ufuzzy';
+import { readConfObject } from "../configuration/index.js";
+import QuickLRU from "../util/QuickLRU/index.js";
+export default class TextSearchManager {
+    pluginManager;
+    adapterCache = new QuickLRU({
+        maxSize: 15,
+    });
+    constructor(pluginManager) {
+        this.pluginManager = pluginManager;
+    }
+    loadTextSearchAdapters(searchScope) {
+        return Promise.all(this.relevantAdapters(searchScope).map(async (conf) => {
+            const adapterId = readConfObject(conf, 'textSearchAdapterId');
+            const r = this.adapterCache.get(adapterId);
+            if (r) {
+                return r;
+            }
+            else {
+                const adapterType = this.pluginManager.getTextSearchAdapterType(conf.type);
+                const AdapterClass = await adapterType.getAdapterClass();
+                const adapterInstance = new AdapterClass(conf, undefined, this.pluginManager);
+                this.adapterCache.set(adapterId, adapterInstance);
+                return adapterInstance;
+            }
+        }));
+    }
+    relevantAdapters(searchScope) {
+        const rootModel = this.pluginManager.rootModel;
+        const { aggregateTextSearchAdapters } = rootModel?.jbrowse;
+        const { tracks } = rootModel?.session;
+        const { assemblyName } = searchScope;
+        return [
+            ...this.getAdaptersWithAssembly(assemblyName, aggregateTextSearchAdapters),
+            ...this.getTrackAdaptersWithAssembly(assemblyName, tracks),
+        ];
+    }
+    getAdaptersWithAssembly(assemblyName, confs) {
+        return confs.filter(c => readConfObject(c, 'assemblyNames')?.includes(assemblyName));
+    }
+    getTrackAdaptersWithAssembly(assemblyName, confs) {
+        return confs
+            .filter(conf => readConfObject(conf, [
+            'textSearching',
+            'textSearchAdapter',
+            'assemblyNames',
+        ])?.includes(assemblyName))
+            .map(conf => conf.textSearching.textSearchAdapter);
+    }
+    async search(args, searchScope, rankFn) {
+        return this.search2({ args, searchScope, rankFn });
+    }
+    async search2({ args, searchScope, rankFn, }) {
+        const adapters = await this.loadTextSearchAdapters(searchScope);
+        const results = await Promise.all(adapters.map(a => a.searchIndex(args)));
+        return this.sortResults2({
+            args,
+            results: results.flat(),
+            rankFn,
+        });
+    }
+    sortResults2({ results, rankFn, args, }) {
+        const uf = new uFuzzy({});
+        const haystack = results.map(r => r.getDisplayString());
+        const needle = args.queryString;
+        const idxs = uf.filter(haystack, needle);
+        const res = [];
+        if (idxs != null && idxs.length > 0) {
+            const info = uf.info(idxs, haystack, needle);
+            const order = uf.sort(info, haystack, needle);
+            for (const element of order) {
+                res.push(results[info.idx[element]]);
+            }
+        }
+        return rankFn(res);
+    }
+}

package/esm/assemblyManager/assembly.d.ts

@@ -0,0 +1,75 @@
+import type PluginManager from '../PluginManager.ts';
+import type { BaseOptions } from '../data_adapters/BaseAdapter/index.ts';
+import type RpcManager from '../rpc/RpcManager.ts';
+import type { Feature, Region } from '../util/index.ts';
+import type { IAnyType, Instance } from '@jbrowse/mobx-state-tree';
+type AdapterConf = Record<string, unknown>;
+type RefNameAliases = Record<string, string>;
+export interface RefNameMap {
+    forwardMap: RefNameAliases;
+    reverseMap: RefNameAliases;
+}
+export interface BasicRegion {
+    start: number;
+    end: number;
+    refName: string;
+    assemblyName: string;
+}
+export default function assemblyFactory(assemblyConfigType: IAnyType, pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
+    configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;
+}, {
+    error: unknown;
+    loadingP: Promise<void> | undefined;
+    volatileRegions: BasicRegion[] | undefined;
+    refNameAliases: RefNameAliases | undefined;
+    canonicalToSeqAdapterRefNames: Record<string, string> | undefined;
+    cytobands: Feature[] | undefined;
+} & {
+    getConf(arg: string): any;
+    readonly lowerCaseRefNameAliases: {
+        [k: string]: string;
+    } | undefined;
+} & {
+    readonly initialized: boolean;
+    readonly name: string;
+    readonly regions: BasicRegion[] | undefined;
+    readonly aliases: string[];
+    readonly displayName: string;
+    hasName(name: string): boolean;
+    readonly allAliases: string[];
+    readonly allRefNames: string[] | undefined;
+    readonly lowerCaseRefNames: string[] | undefined;
+    readonly allRefNamesWithLowerCase: string[] | undefined;
+    readonly rpcManager: RpcManager;
+    readonly refNameColors: string[];
+} & {
+    readonly refNames: string[] | undefined;
+} & {
+    getCanonicalRefName(refName: string): string | undefined;
+    getCanonicalRefName2(refName: string): string;
+    getRefNameColor(refName: string): string | undefined;
+    isValidRefName(refName: string): boolean;
+    getSeqAdapterRefName(canonicalRefName: string): string;
+} & {
+    setLoaded({ regions, refNameAliases, cytobands, }: {
+        regions: Region[];
+        refNameAliases: RefNameAliases;
+        cytobands: Feature[];
+    }): void;
+    setError(e: unknown): void;
+    setRegions(regions: Region[]): void;
+    setRefNameAliases(aliases: RefNameAliases): void;
+    setCytobands(cytobands: Feature[]): void;
+    setCanonicalToSeqAdapterRefNames(map: Record<string, string>): void;
+    setLoadingP(p?: Promise<void>): void;
+    load(): Promise<void>;
+    loadPre(): Promise<void>;
+} & {
+    getAdapterMapEntry(adapterConf: AdapterConf, options: BaseOptions): Promise<RefNameMap>;
+    getRefNameMapForAdapter(adapterConf: AdapterConf, opts: BaseOptions): Promise<RefNameAliases>;
+    getReverseRefNameMapForAdapter(adapterConf: AdapterConf, opts: BaseOptions): Promise<RefNameAliases>;
+    afterCreate(): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export type AssemblyModel = ReturnType<typeof assemblyFactory>;
+export type Assembly = Instance<AssemblyModel>;
+export {};