@jbrowse/core 3.7.0 → 4.0.1

package/esm/pluggableElementTypes/models/BaseViewModel.d.ts

@@ -0,0 +1,52 @@
+import type { MenuItem } from '../../ui/index.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    displayName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+}, {
+    width: number;
+} & {
+    menuItems(): MenuItem[];
+} & {
+    setDisplayName(name: string): void;
+    setWidth(newWidth: number): void;
+    setMinimized(flag: boolean): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree").ModelSnapshotType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    displayName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+}>>;
+export default BaseViewModel;
+export type IBaseViewModel = Instance<typeof BaseViewModel> & {
+    type: string;
+};
+export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    displayName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+} & {
+    displayedRegions: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IModelType<{
+        refName: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+        start: import("@jbrowse/mobx-state-tree").ISimpleType<number>;
+        end: import("@jbrowse/mobx-state-tree").ISimpleType<number>;
+        reversed: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    } & {
+        assemblyName: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    }, {
+        setRefName(newRefName: string): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+}, {
+    width: number;
+} & {
+    menuItems(): MenuItem[];
+} & {
+    setDisplayName(name: string): void;
+    setWidth(newWidth: number): void;
+    setMinimized(flag: boolean): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree").ModelSnapshotType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    displayName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    minimized: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+}>>;
+export type IBaseViewModelWithDisplayedRegions = Instance<typeof BaseViewModelWithDisplayedRegions>;

package/esm/pluggableElementTypes/models/BaseViewModel.js

@@ -0,0 +1,42 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { ElementId, Region } from "../../util/types/mst.js";
+function x() { }
+const BaseViewModel = types
+    .model('BaseView', {
+    id: ElementId,
+    displayName: types.maybe(types.string),
+    minimized: false,
+})
+    .volatile(() => ({
+    width: 800,
+}))
+    .views(() => ({
+    menuItems() {
+        return [];
+    },
+}))
+    .actions(self => ({
+    setDisplayName(name) {
+        self.displayName = name;
+    },
+    setWidth(newWidth) {
+        self.width = newWidth;
+    },
+    setMinimized(flag) {
+        self.minimized = flag;
+    },
+}))
+    .postProcessSnapshot(snap => {
+    if (!snap) {
+        return snap;
+    }
+    const { minimized, ...rest } = snap;
+    return {
+        ...rest,
+        ...(minimized ? { minimized } : {}),
+    };
+});
+export default BaseViewModel;
+export const BaseViewModelWithDisplayedRegions = BaseViewModel.props({
+    displayedRegions: types.array(Region),
+});

package/esm/pluggableElementTypes/models/InternetAccountModel.d.ts

@@ -0,0 +1,86 @@
+import type React from 'react';
+import { RemoteFileWithRangeCache } from '../../util/io/index.ts';
+import type { AnyReactComponentType, UriLocation } from '../../util/types/index.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare const InternetAccount: import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    configuration: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        name: {
+            description: string;
+            type: string;
+            defaultValue: string;
+        };
+        description: {
+            description: string;
+            type: string;
+            defaultValue: string;
+        };
+        authHeader: {
+            description: string;
+            type: string;
+            defaultValue: string;
+        };
+        tokenType: {
+            description: string;
+            type: string;
+            defaultValue: string;
+        };
+        domains: {
+            description: string;
+            type: string;
+            defaultValue: never[];
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>;
+}, {
+    readonly name: string;
+    readonly description: string;
+    readonly internetAccountId: string;
+    readonly authHeader: string;
+    readonly tokenType: string;
+    readonly domains: string[];
+    readonly toggleContents: React.ReactNode;
+    readonly SelectorComponent: AnyReactComponentType | undefined;
+    readonly selectorLabel: string | undefined;
+} & {
+    handlesLocation(location: UriLocation): boolean;
+    readonly tokenKey: string;
+} & {
+    getTokenFromUser(_resolve: (token: string) => void, _reject: (error: Error) => void): void;
+    storeToken(token: string): void;
+    removeToken(): void;
+    retrieveToken(): string | null;
+    validateToken(token: string, _loc: UriLocation): Promise<string>;
+} & {
+    getToken(location?: UriLocation): Promise<string>;
+} & {
+    addAuthHeaderToInit(init?: RequestInit, token?: string): {
+        headers: Headers;
+        body?: BodyInit | null;
+        cache?: RequestCache;
+        credentials?: RequestCredentials;
+        integrity?: string;
+        keepalive?: boolean;
+        method?: string;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        window?: null;
+    };
+    getPreAuthorizationInformation(location: UriLocation): Promise<{
+        internetAccountType: string;
+        authInfo: {
+            token: string;
+            configuration: any;
+        };
+    }>;
+} & {
+    getFetcher(loc?: UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+} & {
+    openLocation(location: UriLocation): RemoteFileWithRangeCache;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export type BaseInternetAccountStateModel = typeof InternetAccount;
+export type BaseInternetAccountModel = Instance<BaseInternetAccountStateModel>;

package/esm/pluggableElementTypes/models/InternetAccountModel.js

@@ -0,0 +1,151 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { BaseInternetAccountConfig } from "./baseInternetAccountConfig.js";
+import { ConfigurationReference, getConf } from "../../configuration/index.js";
+import { RemoteFileWithRangeCache } from "../../util/io/index.js";
+import { ElementId } from "../../util/types/mst.js";
+const inWebWorker = typeof sessionStorage === 'undefined';
+function x() { }
+export const InternetAccount = types
+    .model('InternetAccount', {
+    id: ElementId,
+    type: types.string,
+    configuration: ConfigurationReference(BaseInternetAccountConfig),
+})
+    .views(self => ({
+    get name() {
+        return getConf(self, 'name');
+    },
+    get description() {
+        return getConf(self, 'description');
+    },
+    get internetAccountId() {
+        return getConf(self, 'internetAccountId');
+    },
+    get authHeader() {
+        return getConf(self, 'authHeader');
+    },
+    get tokenType() {
+        return getConf(self, 'tokenType');
+    },
+    get domains() {
+        return getConf(self, 'domains');
+    },
+    get toggleContents() {
+        return null;
+    },
+    get SelectorComponent() {
+        return undefined;
+    },
+    get selectorLabel() {
+        return undefined;
+    },
+}))
+    .views(self => ({
+    handlesLocation(location) {
+        return self.domains.some(domain => location.uri.includes(domain));
+    },
+    get tokenKey() {
+        return `${self.internetAccountId}-token`;
+    },
+}))
+    .actions(self => ({
+    getTokenFromUser(_resolve, _reject) {
+        throw new Error('getTokenFromUser must be implemented by extending model');
+    },
+    storeToken(token) {
+        sessionStorage.setItem(self.tokenKey, token);
+    },
+    removeToken() {
+        sessionStorage.removeItem(self.tokenKey);
+    },
+    retrieveToken() {
+        return sessionStorage.getItem(self.tokenKey);
+    },
+    async validateToken(token, _loc) {
+        return token;
+    },
+}))
+    .actions(self => {
+    let tokenPromise = undefined;
+    return {
+        async getToken(location) {
+            if (tokenPromise) {
+                return tokenPromise;
+            }
+            let token = location?.internetAccountPreAuthorization?.authInfo?.token;
+            if (token) {
+                tokenPromise = Promise.resolve(token);
+                return tokenPromise;
+            }
+            if (inWebWorker) {
+                throw new Error('Did not get internet account pre-authorization info in worker');
+            }
+            token = self.retrieveToken();
+            if (token) {
+                tokenPromise = Promise.resolve(token);
+                return tokenPromise;
+            }
+            tokenPromise = new Promise((resolve, reject) => {
+                self.getTokenFromUser(token => {
+                    self.storeToken(token);
+                    resolve(token);
+                }, error => {
+                    self.removeToken();
+                    reject(error);
+                });
+            });
+            return tokenPromise;
+        },
+    };
+})
+    .actions(self => ({
+    addAuthHeaderToInit(init, token) {
+        return {
+            ...init,
+            headers: new Headers({
+                ...init?.headers,
+                ...(token
+                    ? {
+                        [self.authHeader]: self.tokenType
+                            ? `${self.tokenType} ${token}`
+                            : token,
+                    }
+                    : {}),
+            }),
+        };
+    },
+    async getPreAuthorizationInformation(location) {
+        const authToken = await self.getToken(location);
+        let validatedToken;
+        try {
+            validatedToken = await self.validateToken(authToken, location);
+        }
+        catch (error) {
+            self.removeToken();
+            throw error;
+        }
+        return {
+            internetAccountType: self.type,
+            authInfo: {
+                token: validatedToken,
+                configuration: getConf(self),
+            },
+        };
+    },
+}))
+    .actions(self => ({
+    getFetcher(loc) {
+        return async (input, init) => {
+            const authToken = await self.getToken(loc);
+            const newInit = self.addAuthHeaderToInit(init, authToken);
+            return fetch(input, newInit);
+        };
+    },
+}))
+    .actions(self => ({
+    openLocation(location) {
+        return new RemoteFileWithRangeCache(location.uri, {
+            fetch: self.getFetcher(location),
+        });
+    },
+}));

package/esm/pluggableElementTypes/models/baseConnectionConfig.d.ts

@@ -0,0 +1,16 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+declare const BaseConnectionConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    name: {
+        type: string;
+        defaultValue: string;
+        description: string;
+    };
+    assemblyNames: {
+        type: string;
+        defaultValue: never[];
+        description: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId">>;
+export default BaseConnectionConfig;
+export type BaseConnectionConfigSchema = typeof BaseConnectionConfig;
+export type BaseConnectionConfigModel = Instance<BaseConnectionConfigSchema>;

package/esm/pluggableElementTypes/models/baseConnectionConfig.js

@@ -0,0 +1,18 @@
+import { ConfigurationSchema } from "../../configuration/index.js";
+function x() { }
+const BaseConnectionConfig = ConfigurationSchema('BaseConnection', {
+    name: {
+        type: 'string',
+        defaultValue: 'nameOfConnection',
+        description: 'a unique name for this connection',
+    },
+    assemblyNames: {
+        type: 'stringArray',
+        defaultValue: [],
+        description: 'optional list of names of assemblies in this connection',
+    },
+}, {
+    explicitlyTyped: true,
+    explicitIdentifier: 'connectionId',
+});
+export default BaseConnectionConfig;

package/esm/pluggableElementTypes/models/baseInternetAccountConfig.d.ts

@@ -0,0 +1,27 @@
+export declare const BaseInternetAccountConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    name: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    description: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    authHeader: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    tokenType: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    domains: {
+        description: string;
+        type: string;
+        defaultValue: never[];
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>;

package/esm/pluggableElementTypes/models/baseInternetAccountConfig.js

@@ -0,0 +1,32 @@
+import { ConfigurationSchema } from "../../configuration/index.js";
+function x() { }
+export const BaseInternetAccountConfig = ConfigurationSchema('InternetAccount', {
+    name: {
+        description: 'descriptive name of the internet account',
+        type: 'string',
+        defaultValue: '',
+    },
+    description: {
+        description: 'a description of the internet account',
+        type: 'string',
+        defaultValue: '',
+    },
+    authHeader: {
+        description: 'request header for credentials',
+        type: 'string',
+        defaultValue: 'Authorization',
+    },
+    tokenType: {
+        description: 'a custom name for a token to include in the header',
+        type: 'string',
+        defaultValue: '',
+    },
+    domains: {
+        description: 'array of valid domains the url can contain to use this account',
+        type: 'stringArray',
+        defaultValue: [],
+    },
+}, {
+    explicitIdentifier: 'internetAccountId',
+    explicitlyTyped: true,
+});

package/esm/pluggableElementTypes/models/baseTrackConfig.d.ts

@@ -0,0 +1,87 @@
+import type PluginManager from '../../PluginManager.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    name: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    assemblyNames: {
+        description: string;
+        type: string;
+        defaultValue: string[];
+    };
+    description: {
+        description: string;
+        type: string;
+        defaultValue: string;
+    };
+    category: {
+        description: string;
+        type: string;
+        defaultValue: never[];
+    };
+    metadata: {
+        type: string;
+        description: string;
+        defaultValue: {};
+    };
+    rpcDriverName: {
+        type: string;
+        description: string;
+        defaultValue: string;
+    };
+    adapter: import("@jbrowse/mobx-state-tree").IAnyModelType;
+    textSearching: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        indexingAttributes: {
+            type: string;
+            description: string;
+            defaultValue: string[];
+        };
+        indexingFeatureTypesToExclude: {
+            type: string;
+            description: string;
+            defaultValue: string[];
+        };
+        textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyModelType;
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyModelType>;
+    formatDetails: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        feature: {
+            type: string;
+            description: string;
+            defaultValue: {};
+            contextVariable: string[];
+        };
+        subfeatures: {
+            type: string;
+            description: string;
+            defaultValue: {};
+            contextVariable: string[];
+        };
+        depth: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+        maxDepth: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    formatAbout: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
+        config: {
+            type: string;
+            description: string;
+            defaultValue: {};
+            contextVariable: string[];
+        };
+        hideUris: {
+            type: string;
+            defaultValue: boolean;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "trackId">>;
+export type BaseTrackConfigSchema = ReturnType<typeof createBaseTrackConfig>;
+export type BaseTrackConfig = Instance<BaseTrackConfigSchema>;

package/esm/pluggableElementTypes/models/baseTrackConfig.js

@@ -0,0 +1,134 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { ConfigurationSchema } from "../../configuration/index.js";
+export function createBaseTrackConfig(pluginManager) {
+    return ConfigurationSchema('BaseTrack', {
+        name: {
+            description: 'descriptive name of the track',
+            type: 'string',
+            defaultValue: 'Track',
+        },
+        assemblyNames: {
+            description: 'name of the assembly (or assemblies) track belongs to',
+            type: 'stringArray',
+            defaultValue: ['assemblyName'],
+        },
+        description: {
+            description: 'a description of the track',
+            type: 'string',
+            defaultValue: '',
+        },
+        category: {
+            description: 'the category and sub-categories of a track',
+            type: 'stringArray',
+            defaultValue: [],
+        },
+        metadata: {
+            type: 'frozen',
+            description: 'anything to add about this track',
+            defaultValue: {},
+        },
+        rpcDriverName: {
+            type: 'string',
+            description: 'RPC driver to use for this track. Leave empty to use the display-level or global default.',
+            defaultValue: '',
+        },
+        adapter: pluginManager.pluggableConfigSchemaType('adapter'),
+        textSearching: ConfigurationSchema('textSearching', {
+            indexingAttributes: {
+                type: 'stringArray',
+                description: 'list of which feature attributes to index for text searching',
+                defaultValue: ['Name', 'ID'],
+            },
+            indexingFeatureTypesToExclude: {
+                type: 'stringArray',
+                description: 'list of feature types to exclude in text search index',
+                defaultValue: ['CDS', 'exon'],
+            },
+            textSearchAdapter: pluginManager.pluggableConfigSchemaType('text search adapter'),
+        }),
+        displays: types.array(pluginManager.pluggableConfigSchemaType('display')),
+        formatDetails: ConfigurationSchema('FormatDetails', {
+            feature: {
+                type: 'frozen',
+                description: 'adds extra fields to the feature details',
+                defaultValue: {},
+                contextVariable: ['feature'],
+            },
+            subfeatures: {
+                type: 'frozen',
+                description: 'adds extra fields to the subfeatures of a feature',
+                defaultValue: {},
+                contextVariable: ['feature'],
+            },
+            depth: {
+                type: 'number',
+                defaultValue: 2,
+                description: 'depth of subfeatures to iterate the formatter on formatDetails.subfeatures (e.g. you may not want to format the exon/cds subfeatures, so limited to 2',
+            },
+            maxDepth: {
+                type: 'number',
+                defaultValue: 99999,
+                description: 'Maximum depth to render subfeatures',
+            },
+        }),
+        formatAbout: ConfigurationSchema('FormatAbout', {
+            config: {
+                type: 'frozen',
+                description: 'formats configuration object in about dialog',
+                defaultValue: {},
+                contextVariable: ['config'],
+            },
+            hideUris: {
+                type: 'boolean',
+                defaultValue: false,
+            },
+        }),
+    }, {
+        preProcessSnapshot: s2 => {
+            const snap = pluginManager.evaluateExtensionPoint('Core-preProcessTrackConfig', structuredClone(s2));
+            const { displays = [] } = snap;
+            if (snap.trackId !== 'placeholderId') {
+                try {
+                    const configDisplayTypes = new Set(displays.map(d => d.type));
+                    for (const d of pluginManager.getTrackType(snap.type)
+                        .displayTypes) {
+                        if (!configDisplayTypes.has(d.name)) {
+                            displays.push({
+                                displayId: `${snap.trackId}-${d.name}`,
+                                type: d.name,
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    throw new Error(`Unknown track type "${snap.type}" in ${JSON.stringify(snap)}`, {
+                        cause: e,
+                    });
+                }
+            }
+            return {
+                ...snap,
+                displays: displays.map(d => ({
+                    ...d,
+                    displayId: d.displayId ?? `${snap.trackId}-${d.type}`,
+                })),
+            };
+        },
+        explicitIdentifier: 'trackId',
+        explicitlyTyped: true,
+        actions: (self) => ({
+            addDisplayConf(conf) {
+                const { type } = conf;
+                if (!type) {
+                    throw new Error(`unknown display type ${type}`);
+                }
+                const display = self.displays.find((d) => d?.displayId === conf.displayId);
+                if (display) {
+                    return display;
+                }
+                const length = self.displays.push(conf);
+                return self.displays[length - 1];
+            },
+        }),
+    });
+}

package/esm/pluggableElementTypes/models/components/SaveTrackData.d.ts

@@ -0,0 +1,11 @@
+import type { AnyConfigurationModel } from '../../../configuration/index.ts';
+import type { FileTypeExporter } from '../saveTrackFileTypes/types.ts';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+declare const SaveTrackDataDialog: ({ model, handleClose, }: {
+    model: IAnyStateTreeNode & {
+        configuration: AnyConfigurationModel;
+        saveTrackFileFormatOptions: () => Record<string, FileTypeExporter>;
+    };
+    handleClose: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default SaveTrackDataDialog;