@jbrowse/core 2.1.4 → 2.1.6

package/BaseFeatureWidget/types.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import { IAnyStateTreeNode } from 'mobx-state-tree';
-import { SimpleFeatureSerialized } from '../util/simpleFeature';
+import { SimpleFeatureSerializedNoId } from '../util/simpleFeature';
 import { AbstractViewModel } from '../util';
 export interface BaseProps extends BaseCardProps {
-    feature: SimpleFeatureSerialized;
+    feature: SimpleFeatureSerializedNoId;
     formatter?: (val: unknown, key: string) => React.ReactNode;
     descriptions?: Record<string, React.ReactNode>;
     model?: IAnyStateTreeNode & {

package/BaseFeatureWidget/util.d.ts

@@ -6,13 +6,19 @@ 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;
+    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[];
@@ -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 */
@@ -279,8 +280,8 @@ export default class PluginManager {
     addRpcMethod(cb: (pm: PluginManager) => RpcMethodType): this;
     addInternetAccountType(cb: (pm: PluginManager) => InternetAccountType): this;
     addAddTrackWorkflowType(cb: (pm: PluginManager) => AddTrackWorkflowType): this;
-    addToExtensionPoint<T>(extensionPointName: string, callback: (extendee: T) => T): void;
-    evaluateExtensionPoint(extensionPointName: string, extendee: unknown): unknown;
-    evaluateAsyncExtensionPoint(extensionPointName: string, extendee: unknown): Promise<unknown>;
+    addToExtensionPoint<T>(extensionPointName: string, callback: (extendee: T, props: Record<string, unknown>) => T): void;
+    evaluateExtensionPoint(extensionPointName: string, extendee: unknown, props?: Record<string, unknown>): unknown;
+    evaluateAsyncExtensionPoint(extensionPointName: string, extendee: unknown, props?: Record<string, unknown>): Promise<unknown>;
 }
 export {};

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)
@@ -329,7 +335,9 @@ class PluginManager {
             const displays = this.getElementTypesInGroup('display');
             displays.forEach(display => {
                 // view may have already added the displayType in its callback
-                if (display.viewType === newView.name &&
+                // see ViewType for description of extendedName
+                if ((display.viewType === newView.name ||
+                    display.viewType === newView.extendedName) &&
                     !newView.displayTypes.includes(display)) {
                     newView.addDisplayType(display);
                 }
@@ -361,13 +369,13 @@ class PluginManager {
         }
         callbacks.push(callback);
     }
-    evaluateExtensionPoint(extensionPointName, extendee) {
+    evaluateExtensionPoint(extensionPointName, extendee, props) {
         const callbacks = this.extensionPoints.get(extensionPointName);
         let accumulator = extendee;
         if (callbacks) {
             for (const callback of callbacks) {
                 try {
-                    accumulator = callback(accumulator);
+                    accumulator = callback(accumulator, props);
                 }
                 catch (error) {
                     console.error(error);
@@ -376,13 +384,13 @@ class PluginManager {
         }
         return accumulator;
     }
-    async evaluateAsyncExtensionPoint(extensionPointName, extendee) {
+    async evaluateAsyncExtensionPoint(extensionPointName, extendee, props) {
         const callbacks = this.extensionPoints.get(extensionPointName);
         let accumulator = extendee;
         if (callbacks) {
             for (const callback of callbacks) {
                 try {
-                    accumulator = await callback(accumulator);
+                    accumulator = await callback(accumulator, props);
                 }
                 catch (error) {
                     console.error(error);

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 });
 }