@jbrowse/core 2.1.5 → 2.1.7

package/BaseFeatureWidget/SequencePanel.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const util_1 = require("../util");
+const util_2 = require("./util");
+const SequenceBox_1 = require("./SequenceBox");
+const SequencePanel = react_1.default.forwardRef((props, ref) => {
+    const { feature, mode, intronBp = 10 } = props;
+    let { sequence: { seq, upstream = '', downstream = '' }, } = props;
+    const { subfeatures = [] } = feature;
+    const children = subfeatures
+        .sort((a, b) => a.start - b.start)
+        .map(sub => ({
+        ...sub,
+        start: sub.start - feature.start,
+        end: sub.end - feature.start,
+    }));
+    // we filter duplicate entries in cds and exon lists duplicate entries may be
+    // rare but was seen in Gencode v36 track NCList, likely a bug on GFF3 or
+    // probably worth ignoring here (produces broken protein translations if
+    // included)
+    //
+    // position 1:224,800,006..225,203,064 gene ENSG00000185842.15 first
+    // transcript ENST00000445597.6
+    //
+    // http://localhost:3000/?config=test_data%2Fconfig.json&session=share-FUl7G1isvF&password=HXh5Y
+    let cds = (0, util_2.dedupe)(children.filter(sub => sub.type === 'CDS'));
+    let utr = (0, util_2.dedupe)(children.filter(sub => sub.type.match(/utr/i)));
+    let exons = (0, util_2.dedupe)(children.filter(sub => sub.type === 'exon'));
+    if (!utr.length && cds.length && exons.length) {
+        utr = (0, util_2.calculateUTRs)(cds, exons);
+    }
+    if (!utr.length && cds.length && !exons.length) {
+        utr = (0, util_2.calculateUTRs2)(cds, {
+            start: 0,
+            end: feature.end - feature.start,
+            type: 'gene',
+        });
+    }
+    if (feature.strand === -1) {
+        // doing this in a single assignment is needed because downstream and
+        // upstream are swapped so this avoids a temp variable
+        ;
+        [seq, upstream, downstream] = [
+            (0, util_1.revcom)(seq),
+            (0, util_1.revcom)(downstream),
+            (0, util_1.revcom)(upstream),
+        ];
+        cds = (0, util_2.revlist)(cds, seq.length);
+        exons = (0, util_2.revlist)(exons, seq.length);
+        utr = (0, util_2.revlist)(utr, seq.length);
+    }
+    const codonTable = (0, util_1.generateCodonTable)(util_1.defaultCodonTable);
+    return (react_1.default.createElement("div", { ref: ref, "data-testid": "sequence_panel" },
+        react_1.default.createElement("div", { style: {
+                fontFamily: 'monospace',
+                wordWrap: 'break-word',
+                overflow: 'auto',
+                fontSize: 12,
+                maxWidth: 600,
+                maxHeight: 500,
+            } },
+            `>${feature.name ||
+                feature.id ||
+                feature.refName + ':' + (feature.start + 1) + '-' + feature.end}-${mode}\n`,
+            react_1.default.createElement("br", null),
+            mode === 'genomic' ? (react_1.default.createElement(SequenceBox_1.Genomic, { sequence: seq })) : mode === 'genomic_sequence_updown' ? (react_1.default.createElement(SequenceBox_1.Genomic, { sequence: seq, upstream: upstream, downstream: downstream })) : mode === 'cds' ? (react_1.default.createElement(SequenceBox_1.GeneCDS, { cds: cds, sequence: seq })) : mode === 'cdna' ? (react_1.default.createElement(SequenceBox_1.GenecDNA, { exons: exons, cds: cds, utr: utr, sequence: seq, intronBp: intronBp })) : mode === 'protein' ? (react_1.default.createElement(SequenceBox_1.GeneProtein, { cds: cds, codonTable: codonTable, sequence: seq })) : mode === 'gene' ? (react_1.default.createElement(SequenceBox_1.GenecDNA, { exons: exons, cds: cds, utr: utr, sequence: seq, includeIntrons: true, intronBp: intronBp })) : mode === 'gene_collapsed_intron' ? (react_1.default.createElement(SequenceBox_1.GenecDNA, { exons: exons, cds: cds, sequence: seq, utr: utr, includeIntrons: true, collapseIntron: true, intronBp: intronBp })) : mode === 'gene_updownstream' ? (react_1.default.createElement(SequenceBox_1.GenecDNA, { exons: exons, cds: cds, sequence: seq, utr: utr, upstream: upstream, downstream: downstream, includeIntrons: true, intronBp: intronBp })) : mode === 'gene_updownstream_collapsed_intron' ? (react_1.default.createElement(SequenceBox_1.GenecDNA, { exons: exons, cds: cds, sequence: seq, utr: utr, upstream: upstream, downstream: downstream, includeIntrons: true, collapseIntron: true, intronBp: intronBp })) : (react_1.default.createElement("div", null, "Unknown type")))));
+});
+exports.default = SequencePanel;

package/BaseFeatureWidget/index.d.ts

@@ -8,10 +8,13 @@ export default function stateModelFactory(pluginManager: PluginManager): import(
     unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
     view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
     track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
 }, {
     setFeatureData(featureData: Record<string, unknown>): void;
     clearFeatureData(): void;
     setFormattedData(feat: Record<string, unknown>): void;
+    setExtra(type?: string, trackId?: string): void;
 } & {
     afterCreate(): void;
 }, import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
@@ -22,11 +25,15 @@ export default function stateModelFactory(pluginManager: PluginManager): import(
     unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
     view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
     track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
 }>>, {
     id: string;
     type: "BaseFeatureWidget";
     track: import("mobx-state-tree").ReferenceIdentifier | undefined;
     view: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    trackId: string | undefined;
+    trackType: string | undefined;
     formattedFields: any;
     finalizedFeatureData: any;
 }>;

package/BaseFeatureWidget/index.js

@@ -6,8 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stateModelFactory = exports.configSchema = void 0;
 const mobx_state_tree_1 = require("mobx-state-tree");
 const mobx_1 = require("mobx");
-const configuration_1 = require("../configuration");
 const clone_1 = __importDefault(require("clone"));
+const configuration_1 = require("../configuration");
+const util_1 = require("../util");
 const mst_1 = require("../util/types/mst");
 const configSchema = (0, configuration_1.ConfigurationSchema)('BaseFeatureWidget', {});
 exports.configSchema = configSchema;
@@ -32,8 +33,9 @@ function stateModelFactory(pluginManager) {
         unformattedFeatureData: mobx_state_tree_1.types.frozen(),
         view: mobx_state_tree_1.types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
         track: mobx_state_tree_1.types.safeReference(pluginManager.pluggableMstType('track', 'stateModel')),
+        trackId: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+        trackType: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
     })
-        .volatile(() => ({}))
         .actions(self => ({
         setFeatureData(featureData) {
             self.unformattedFeatureData = featureData;
@@ -44,20 +46,34 @@ function stateModelFactory(pluginManager) {
         setFormattedData(feat) {
             self.featureData = feat;
         },
+        setExtra(type, trackId) {
+            self.trackId = trackId;
+            self.trackType = type;
+        },
     }))
         .actions(self => ({
         afterCreate() {
             (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(() => {
+                var _a, _b;
+                self.setExtra((_a = self.track) === null || _a === void 0 ? void 0 : _a.type, (_b = self.track) === null || _b === void 0 ? void 0 : _b.configuration.trackId);
                 const { unformattedFeatureData, track } = self;
+                const session = (0, util_1.getSession)(self);
                 if (unformattedFeatureData) {
                     const feature = (0, clone_1.default)(unformattedFeatureData);
+                    const f = (obj, arg2) => (0, configuration_1.getConf)(obj, ['formatDetails', arg2], { feature });
                     if (track) {
                         // eslint-disable-next-line no-underscore-dangle
-                        feature.__jbrowsefmt = (0, configuration_1.getConf)(track, ['formatDetails', 'feature'], { feature });
+                        feature.__jbrowsefmt = {
+                            ...f(session, 'feature'),
+                            ...f(track, 'feature'),
+                        };
                         const depth = (0, configuration_1.getConf)(track, ['formatDetails', 'depth']);
-                        formatSubfeatures(feature, depth, subfeature => {
+                        formatSubfeatures(feature, depth, sub => {
                             // eslint-disable-next-line no-underscore-dangle
-                            subfeature.__jbrowsefmt = (0, configuration_1.getConf)(track, ['formatDetails', 'subfeatures'], { feature: subfeature });
+                            sub.__jbrowsefmt = {
+                                ...f(session, 'subfeature'),
+                                ...f(track, 'subfeature'),
+                            };
                         });
                     }
                     self.setFormattedData(feature);

package/BaseFeatureWidget/util.d.ts

@@ -6,14 +6,20 @@ export interface Feat {
     id?: string;
 }
 export interface ParentFeat extends Feat {
+    uniqueId: string;
     strand?: number;
+    refName: string;
     subfeatures?: Feat[];
+    parentId?: string;
 }
 export interface SeqState {
     seq: string;
     upstream?: string;
     downstream?: string;
 }
+export interface ErrorState {
+    error: string;
+}
 export declare function stitch(subfeats: Feat[], sequence: string): string;
 export declare function dedupe(list: Feat[]): Feat[];
 export declare function revlist(list: Feat[], seqlen: number): {
@@ -28,4 +34,9 @@ export declare function calculateUTRs(cds: Feat[], exons: Feat[]): {
     start: number;
     end: number;
 }[];
+export declare function calculateUTRs2(cds: Feat[], parentFeat: Feat): {
+    type: string;
+    start: number;
+    end: number;
+}[];
 export declare function ellipses(slug: string): string;

package/BaseFeatureWidget/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ellipses = exports.calculateUTRs = exports.revlist = exports.dedupe = exports.stitch = void 0;
+exports.ellipses = exports.calculateUTRs2 = exports.calculateUTRs = exports.revlist = exports.dedupe = exports.stitch = void 0;
 function stitch(subfeats, sequence) {
     return subfeats.map(sub => sequence.slice(sub.start, sub.end)).join('');
 }
@@ -43,6 +43,18 @@ function calculateUTRs(cds, exons) {
     return [...fiveUTRs, ...threeUTRs];
 }
 exports.calculateUTRs = calculateUTRs;
+// calculates UTRs using impliedUTRs logic, but there are no exon subfeatures
+function calculateUTRs2(cds, parentFeat) {
+    const firstCds = cds[0];
+    const lastCds = cds[cds.length - 1];
+    const fiveUTRs = [{ start: parentFeat.start, end: firstCds.start }].map(elt => ({ ...elt, type: 'five_prime_UTR' }));
+    const threeUTRs = [{ start: lastCds.end, end: parentFeat.end }].map(elt => ({
+        ...elt,
+        type: 'three_prime_UTR',
+    }));
+    return [...fiveUTRs, ...threeUTRs];
+}
+exports.calculateUTRs2 = calculateUTRs2;
 function ellipses(slug) {
     return slug.length > 20 ? `${slug.slice(0, 20)}...` : slug;
 }

package/PluginLoader.d.ts

@@ -1,6 +1,12 @@
 import { PluginConstructor } from './Plugin';
-export declare const PluginSourceConfigurationSchema: import("./configuration").AnyConfigurationSchemaType;
-export interface UMDPluginDefinition {
+export interface UMDLocPluginDefinition {
+    umdLoc: {
+        uri: string;
+        baseUri?: string;
+    };
+    name: string;
+}
+export interface UMDUrlPluginDefinition {
     umdUrl: string;
     name: string;
 }
@@ -8,16 +14,24 @@ export interface LegacyUMDPluginDefinition {
     url: string;
     name: string;
 }
-export declare function isUMDPluginDefinition(pluginDefinition: PluginDefinition): pluginDefinition is UMDPluginDefinition | LegacyUMDPluginDefinition;
-export interface ESMPluginDefinition {
+declare type UMDPluginDefinition = UMDLocPluginDefinition | UMDUrlPluginDefinition;
+export declare function isUMDPluginDefinition(def: PluginDefinition): def is UMDPluginDefinition | LegacyUMDPluginDefinition;
+export interface ESMLocPluginDefinition {
+    esmLoc: {
+        uri: string;
+        baseUri?: string;
+    };
+}
+export interface ESMUrlPluginDefinition {
     esmUrl: string;
 }
-export declare function isESMPluginDefinition(pluginDefinition: PluginDefinition): pluginDefinition is ESMPluginDefinition;
+export declare type ESMPluginDefinition = ESMLocPluginDefinition | ESMUrlPluginDefinition;
+export declare function isESMPluginDefinition(def: PluginDefinition): def is ESMPluginDefinition;
 export interface CJSPluginDefinition {
     cjsUrl: string;
 }
-export declare function isCJSPluginDefinition(pluginDefinition: PluginDefinition): pluginDefinition is CJSPluginDefinition;
-export interface PluginDefinition extends Partial<UMDPluginDefinition>, Partial<LegacyUMDPluginDefinition>, Partial<ESMPluginDefinition>, Partial<CJSPluginDefinition> {
+export declare function isCJSPluginDefinition(def: PluginDefinition): def is CJSPluginDefinition;
+export interface PluginDefinition extends Partial<UMDUrlPluginDefinition>, Partial<UMDLocPluginDefinition>, Partial<LegacyUMDPluginDefinition>, Partial<ESMLocPluginDefinition>, Partial<ESMUrlPluginDefinition>, Partial<CJSPluginDefinition> {
 }
 export interface PluginRecord {
     plugin: PluginConstructor;
@@ -26,24 +40,26 @@ export interface PluginRecord {
 export interface LoadedPlugin {
     default: PluginConstructor;
 }
+export declare function getWindowPath(windowHref: string): string;
 export default class PluginLoader {
     definitions: PluginDefinition[];
     fetchESM?: (url: string) => Promise<unknown>;
     fetchCJS?: (url: string) => Promise<LoadedPlugin>;
-    constructor(pluginDefinitions?: PluginDefinition[], args?: {
+    constructor(defs?: PluginDefinition[], args?: {
         fetchESM?: (url: string) => Promise<unknown>;
         fetchCJS?: (url: string) => Promise<LoadedPlugin>;
     });
     loadScript(scriptUrl: string): Promise<void>;
-    loadCJSPlugin({ cjsUrl }: CJSPluginDefinition): Promise<LoadedPlugin>;
-    loadESMPlugin(pluginDefinition: ESMPluginDefinition): Promise<LoadedPlugin>;
-    loadUMDPlugin(pluginDefinition: UMDPluginDefinition | LegacyUMDPluginDefinition): Promise<{
+    loadCJSPlugin(def: CJSPluginDefinition, windowHref: string): Promise<LoadedPlugin>;
+    loadESMPlugin(def: ESMPluginDefinition, windowHref: string): Promise<LoadedPlugin>;
+    loadUMDPlugin(def: UMDPluginDefinition | LegacyUMDPluginDefinition, windowHref: string): Promise<{
         default: PluginConstructor;
     }>;
-    loadPlugin(definition: PluginDefinition): Promise<PluginConstructor>;
+    loadPlugin(def: PluginDefinition, windowHref: string): Promise<PluginConstructor>;
     installGlobalReExports(target: WindowOrWorkerGlobalScope): void;
-    load(): Promise<{
+    load(windowHref?: string): Promise<{
         plugin: PluginConstructor;
         definition: PluginDefinition;
     }[]>;
 }
+export {};

package/PluginLoader.js

@@ -3,36 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCJSPluginDefinition = exports.isESMPluginDefinition = exports.isUMDPluginDefinition = exports.PluginSourceConfigurationSchema = void 0;
+exports.getWindowPath = exports.isCJSPluginDefinition = exports.isESMPluginDefinition = exports.isUMDPluginDefinition = void 0;
 const load_script2_1 = __importDefault(require("load-script2"));
-const configuration_1 = require("./configuration");
 const ReExports_1 = __importDefault(require("./ReExports"));
 const util_1 = require("./util");
-exports.PluginSourceConfigurationSchema = (0, configuration_1.ConfigurationSchema)('PluginSource', {
-    name: {
-        type: 'string',
-        defaultValue: '',
-    },
-    url: {
-        type: 'string',
-        defaultValue: '',
-    },
-});
-function isUMDPluginDefinition(pluginDefinition) {
-    return ((pluginDefinition.umdUrl !== undefined ||
-        pluginDefinition.url !== undefined) &&
-        pluginDefinition
-            .name !== undefined);
+function isUMDPluginDefinition(def) {
+    return ((def.umdUrl !== undefined ||
+        def.url !== undefined ||
+        def.umdLoc !== undefined) &&
+        def.name !== undefined);
 }
 exports.isUMDPluginDefinition = isUMDPluginDefinition;
-function isESMPluginDefinition(pluginDefinition) {
-    return pluginDefinition.esmUrl !== undefined;
+function isESMPluginDefinition(def) {
+    return (def.esmUrl !== undefined ||
+        def.esmLoc !== undefined);
 }
 exports.isESMPluginDefinition = isESMPluginDefinition;
-function isCJSPluginDefinition(pluginDefinition) {
-    return pluginDefinition.cjsUrl !== undefined;
+function isCJSPluginDefinition(def) {
+    return def.cjsUrl !== undefined;
 }
 exports.isCJSPluginDefinition = isCJSPluginDefinition;
+function getWindowPath(windowHref) {
+    return window.location.href + windowHref;
+}
+exports.getWindowPath = getWindowPath;
 function getGlobalObject() {
     // Based on window-or-global
     // https://github.com/purposeindustries/window-or-global/blob/322abc71de0010c9e5d9d0729df40959e1ef8775/lib/index.js
@@ -47,42 +41,27 @@ function isInWebWorker(globalObject) {
     return Boolean('WorkerGlobalScope' in globalObject);
 }
 class PluginLoader {
-    constructor(pluginDefinitions = [], args) {
+    constructor(defs = [], args) {
         this.definitions = [];
         this.fetchESM = args === null || args === void 0 ? void 0 : args.fetchESM;
         this.fetchCJS = args === null || args === void 0 ? void 0 : args.fetchCJS;
-        this.definitions = JSON.parse(JSON.stringify(pluginDefinitions));
+        this.definitions = JSON.parse(JSON.stringify(defs));
     }
-    loadScript(scriptUrl) {
+    async loadScript(scriptUrl) {
         const globalObject = getGlobalObject();
         if (!isInWebWorker(globalObject)) {
             return (0, load_script2_1.default)(scriptUrl);
         }
         // @ts-ignore
-        if (globalObject && globalObject.importScripts) {
-            return new Promise((resolve, reject) => {
-                try {
-                    // @ts-ignore
-                    globalObject.importScripts(scriptUrl);
-                }
-                catch (error) {
-                    reject(error || new Error(`failed to load ${scriptUrl}`));
-                    return;
-                }
-                resolve();
-            });
+        if (globalObject === null || globalObject === void 0 ? void 0 : globalObject.importScripts) {
+            // @ts-ignore
+            await globalObject.importScripts(scriptUrl);
+            return;
         }
         throw new Error('cannot figure out how to load external JS scripts in this environment');
     }
-    async loadCJSPlugin({ cjsUrl }) {
-        let parsedUrl;
-        try {
-            parsedUrl = new URL(cjsUrl, getGlobalObject().location.href);
-        }
-        catch (error) {
-            console.error(error);
-            throw new Error(`Error parsing URL: ${cjsUrl}`);
-        }
+    async loadCJSPlugin(def, windowHref) {
+        const parsedUrl = new URL(def.cjsUrl, windowHref);
         if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
             throw new Error(`Cannot load plugins using protocol "${parsedUrl.protocol}"`);
         }
@@ -91,16 +70,11 @@ class PluginLoader {
         }
         return this.fetchCJS(parsedUrl.href);
     }
-    async loadESMPlugin(pluginDefinition) {
+    async loadESMPlugin(def, windowHref) {
         var _a;
-        let parsedUrl;
-        try {
-            parsedUrl = new URL(pluginDefinition.esmUrl, getGlobalObject().location.href);
-        }
-        catch (error) {
-            console.error(error);
-            throw new Error(`Error parsing URL: ${pluginDefinition.esmUrl}`);
-        }
+        const parsedUrl = 'esmUrl' in def
+            ? new URL(def.esmUrl, windowHref)
+            : new URL(def.esmLoc.uri, def.esmLoc.baseUri);
         if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
             throw new Error(`cannot load plugins using protocol "${parsedUrl.protocol}"`);
         }
@@ -110,21 +84,17 @@ class PluginLoader {
         }
         return plugin;
     }
-    async loadUMDPlugin(pluginDefinition) {
-        const umdUrl = 'url' in pluginDefinition ? pluginDefinition.url : pluginDefinition.umdUrl;
-        let parsedUrl;
-        try {
-            parsedUrl = new URL(umdUrl, getGlobalObject().location.href);
-        }
-        catch (error) {
-            console.error(error);
-            throw new Error(`Error parsing URL: ${umdUrl}`);
-        }
+    async loadUMDPlugin(def, windowHref) {
+        const parsedUrl = 'url' in def
+            ? new URL(def.url, windowHref)
+            : 'umdUrl' in def
+                ? new URL(def.umdUrl, windowHref)
+                : new URL(def.umdLoc.uri, def.umdLoc.baseUri);
         if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
             throw new Error(`cannot load plugins using protocol "${parsedUrl.protocol}"`);
         }
         await this.loadScript(parsedUrl.href);
-        const moduleName = pluginDefinition.name;
+        const moduleName = def.name;
         const umdName = `JBrowsePlugin${moduleName}`;
         const globalObject = getGlobalObject();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -134,22 +104,22 @@ class PluginLoader {
         }
         return plugin;
     }
-    async loadPlugin(definition) {
+    async loadPlugin(def, windowHref) {
         let plugin;
-        if (util_1.isElectron && isCJSPluginDefinition(definition)) {
-            plugin = await this.loadCJSPlugin(definition);
+        if (util_1.isElectron && isCJSPluginDefinition(def)) {
+            plugin = await this.loadCJSPlugin(def, windowHref);
         }
-        else if (isESMPluginDefinition(definition)) {
-            plugin = await this.loadESMPlugin(definition);
+        else if (isESMPluginDefinition(def)) {
+            plugin = await this.loadESMPlugin(def, windowHref);
         }
-        else if (isUMDPluginDefinition(definition)) {
-            plugin = await this.loadUMDPlugin(definition);
+        else if (isUMDPluginDefinition(def)) {
+            plugin = await this.loadUMDPlugin(def, windowHref);
         }
-        else if (!util_1.isElectron && isCJSPluginDefinition(definition)) {
-            throw new Error(`Only CommonJS plugin found, but not in a NodeJS environment: ${JSON.stringify(definition)}`);
+        else if (!util_1.isElectron && isCJSPluginDefinition(def)) {
+            throw new Error(`CommonJS plugin found, but not in a NodeJS environment: ${JSON.stringify(def)}`);
         }
         else {
-            throw new Error(`Could not determine plugin type: ${JSON.stringify(definition)}`);
+            throw new Error(`Could not determine plugin type: ${JSON.stringify(def)}`);
         }
         return plugin.default;
     }
@@ -159,9 +129,9 @@ class PluginLoader {
             return [moduleName, module];
         }));
     }
-    async load() {
+    async load(windowHref = '') {
         return Promise.all(this.definitions.map(async (definition) => ({
-            plugin: await this.loadPlugin(definition),
+            plugin: await this.loadPlugin(definition, windowHref),
             definition,
         })));
     }

package/PluginManager.d.ts

@@ -98,6 +98,7 @@ export default class PluginManager {
     addElementType(groupName: PluggableElementTypeGroup, creationCallback: (pluginManager: PluginManager) => PluggableElementType): this;
     getElementType(groupName: PluggableElementTypeGroup, typeName: string): PluggableElementBase;
     getElementTypesInGroup(groupName: PluggableElementTypeGroup): PluggableElementBase[];
+    getRpcElements(): RpcMethodType[];
     /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName: PluggableElementTypeGroup, fieldName: PluggableElementMember, fallback?: IAnyType): IAnyType;
     /** get a MST type for the union of all specified pluggable config schemas */

package/PluginManager.js

@@ -16,7 +16,6 @@ const InternetAccountType_1 = __importDefault(require("./pluggableElementTypes/I
 const TextSearchAdapterType_1 = __importDefault(require("./pluggableElementTypes/TextSearchAdapterType"));
 const AddTrackWorkflowType_1 = __importDefault(require("./pluggableElementTypes/AddTrackWorkflowType"));
 const configuration_1 = require("./configuration");
-const Plugin_1 = __importDefault(require("./Plugin"));
 const ReExports_1 = __importDefault(require("./ReExports"));
 const CorePlugin_1 = __importDefault(require("./CorePlugin"));
 const jexl_1 = __importDefault(require("./util/jexl"));
@@ -140,12 +139,17 @@ class PluginManager {
         if (this.configured) {
             throw new Error('JBrowse already configured, cannot add plugins');
         }
-        const [plugin, metadata = {}] = load instanceof Plugin_1.default ? [load, {}] : [load.plugin, load.metadata];
+        // check for availability of 'install' and 'configure' as a proxy for being
+        // an 'instanceof Plugin'
+        const [plugin, metadata = {}] = 'install' in load && 'configure' in load
+            ? [load, {}]
+            : [load.plugin, load.metadata];
         if (this.plugins.includes(plugin)) {
             throw new Error('plugin already installed');
         }
         this.pluginMetadata[plugin.name] = metadata;
         if ('definition' in load) {
+            // @ts-ignore
             this.runtimePluginDefinitions.push(load.definition);
         }
         plugin.install(this);
@@ -176,7 +180,6 @@ class PluginManager {
         }
         this.plugins.forEach(plugin => plugin.configure(this));
         this.configured = true;
-        // console.log(JSON.stringify(getSnapshot(model)))
         return this;
     }
     getElementTypeRecord(groupName) {
@@ -231,6 +234,9 @@ class PluginManager {
     getElementTypesInGroup(groupName) {
         return this.getElementTypeRecord(groupName).all();
     }
+    getRpcElements() {
+        return this.getElementTypesInGroup('rpc method');
+    }
     /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName, fieldName, fallback = mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.null)) {
         const pluggableTypes = this.getElementTypeRecord(groupName)

package/assemblyManager/assembly.d.ts

@@ -7,6 +7,10 @@ export interface BaseOptions {
     sessionId: string;
     statusCallback?: Function;
 }
+export interface RefNameMap {
+    forwardMap: RefNameAliases;
+    reverseMap: RefNameAliases;
+}
 export interface BasicRegion {
     start: number;
     end: number;
@@ -48,30 +52,19 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
     }): void;
     setError(e: Error): void;
     setRegions(regions: Region[]): void;
-    setRefNameAliases(refNameAliases: RefNameAliases, lowerCaseRefNameAliases: RefNameAliases): void;
+    setRefNameAliases(aliases: RefNameAliases, lowerCase: RefNameAliases): void;
     setCytobands(cytobands: Feature[]): void;
     afterAttach(): void;
 } & {
-    getAdapterMapEntry(adapterConf: unknown, options: BaseOptions): Promise<{
-        forwardMap: {
-            [key: string]: string;
-        };
-        reverseMap: {
-            [key: string]: string;
-        };
-    }>;
+    getAdapterMapEntry(adapterConf: unknown, options: BaseOptions): Promise<RefNameMap>;
     /**
      * get Map of `canonical-name -> adapter-specific-name`
      */
-    getRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<{
-        [key: string]: string;
-    }>;
+    getRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<RefNameAliases>;
     /**
      * get Map of `adapter-specific-name -> canonical-name`
      */
-    getReverseRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<{
-        [key: string]: string;
-    }>;
+    getReverseRefNameMapForAdapter(adapterConf: unknown, opts: BaseOptions): Promise<RefNameAliases>;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export declare type AssemblyModel = ReturnType<typeof assemblyFactory>;
 export declare type Assembly = Instance<AssemblyModel>;

package/assemblyManager/assembly.js

@@ -186,9 +186,9 @@ function assemblyFactory(assemblyConfigType, pluginManager) {
         setRegions(regions) {
             self.regions = regions;
         },
-        setRefNameAliases(refNameAliases, lowerCaseRefNameAliases) {
-            self.refNameAliases = refNameAliases;
-            self.lowerCaseRefNameAliases = lowerCaseRefNameAliases;
+        setRefNameAliases(aliases, lowerCase) {
+            self.refNameAliases = aliases;
+            self.lowerCaseRefNameAliases = lowerCase;
         },
         setCytobands(cytobands) {
             self.cytobands = cytobands;
@@ -292,25 +292,22 @@ async function loadAssemblyReaction(props, signal) {
         cytobands,
     };
 }
-async function getRefNameAliases(config, pluginManager, signal) {
-    var _a;
-    const type = pluginManager.getAdapterType(config.type);
-    const CLASS = await ((_a = type.getAdapterClass) === null || _a === void 0 ? void 0 : _a.call(type));
-    const adapter = new CLASS(config, undefined, pluginManager);
-    return adapter.getRefNameAliases({
-        signal,
-    });
+async function getRefNameAliases(config, pm, signal) {
+    const type = pm.getAdapterType(config.type);
+    const CLASS = await type.getAdapterClass();
+    const adapter = new CLASS(config, undefined, pm);
+    return adapter.getRefNameAliases({ signal });
 }
-async function getCytobands(config, pluginManager) {
-    const type = pluginManager.getAdapterType(config.type);
+async function getCytobands(config, pm) {
+    const type = pm.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();
-    const adapter = new CLASS(config, undefined, pluginManager);
+    const adapter = new CLASS(config, undefined, pm);
     // @ts-ignore
     return adapter.getData();
 }
-async function getAssemblyRegions(config, pluginManager, signal) {
-    const type = pluginManager.getAdapterType(config.type);
+async function getAssemblyRegions(config, pm, signal) {
+    const type = pm.getAdapterType(config.type);
     const CLASS = await type.getAdapterClass();
-    const adapter = new CLASS(config, undefined, pluginManager);
+    const adapter = new CLASS(config, undefined, pm);
     return adapter.getRegions({ signal });
 }