@jbrowse/core 3.7.0 → 4.0.1

package/esm/PluginLoader.d.ts

@@ -0,0 +1,64 @@
+import type { PluginConstructor } from './Plugin.ts';
+export interface UMDLocPluginDefinition {
+    umdLoc: {
+        uri: string;
+        baseUri?: string;
+    };
+    name: string;
+}
+export interface UMDUrlPluginDefinition {
+    umdUrl: string;
+    name: string;
+}
+export interface LegacyUMDPluginDefinition {
+    url: string;
+    name: string;
+}
+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 type ESMPluginDefinition = ESMLocPluginDefinition | ESMUrlPluginDefinition;
+export declare function isESMPluginDefinition(def: PluginDefinition): def is ESMPluginDefinition;
+export interface CJSPluginDefinition {
+    cjsUrl: string;
+}
+export declare function isCJSPluginDefinition(def: PluginDefinition): def is CJSPluginDefinition;
+export type PluginDefinition = UMDUrlPluginDefinition | UMDLocPluginDefinition | LegacyUMDPluginDefinition | ESMLocPluginDefinition | ESMUrlPluginDefinition | CJSPluginDefinition;
+export interface PluginRecord {
+    plugin: PluginConstructor;
+    definition: PluginDefinition;
+}
+export interface LoadedPlugin {
+    default: PluginConstructor;
+}
+export declare function pluginDescriptionString(d: PluginDefinition): string;
+export declare function pluginUrl(d: PluginDefinition): any;
+export default class PluginLoader {
+    definitions: PluginDefinition[];
+    fetchESM?: (url: string) => Promise<LoadedPlugin>;
+    fetchCJS?: (url: string) => Promise<LoadedPlugin>;
+    constructor(defs?: PluginDefinition[], args?: {
+        fetchESM?: (url: string) => Promise<LoadedPlugin>;
+        fetchCJS?: (url: string) => Promise<LoadedPlugin>;
+    });
+    loadCJSPlugin(def: CJSPluginDefinition, baseUri?: string): Promise<LoadedPlugin>;
+    loadESMPlugin(def: ESMPluginDefinition, baseUri?: string): Promise<LoadedPlugin>;
+    loadUMDPlugin(def: UMDPluginDefinition | LegacyUMDPluginDefinition, baseUri?: string): Promise<{
+        default: PluginConstructor;
+    }>;
+    loadPlugin(def: PluginDefinition, baseUri?: string): Promise<PluginConstructor>;
+    installGlobalReExports(target: WindowOrWorkerGlobalScope): this;
+    load(baseUri?: string): Promise<{
+        plugin: PluginConstructor;
+        definition: PluginDefinition;
+    }[]>;
+}
+export {};

package/esm/PluginLoader.js

@@ -0,0 +1,164 @@
+import domLoadScript from 'load-script';
+import Plugin from "./Plugin.js";
+import ReExports from "./ReExports/index.js";
+import { isElectron } from "./util/index.js";
+export function isUMDPluginDefinition(def) {
+    return ((def.umdUrl !== undefined ||
+        def.url !== undefined ||
+        def.umdLoc !== undefined) &&
+        def.name !== undefined);
+}
+export function isESMPluginDefinition(def) {
+    return (def.esmUrl !== undefined ||
+        def.esmLoc !== undefined);
+}
+function promisifiedLoadScript(src) {
+    return new Promise((resolve, reject) => {
+        domLoadScript(src, (err, script) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(script.src);
+            }
+        });
+    });
+}
+async function loadScript(scriptUrl) {
+    if (!isInWebWorker()) {
+        return promisifiedLoadScript(scriptUrl);
+    }
+    if (globalThis.importScripts) {
+        await globalThis.importScripts(scriptUrl);
+        return;
+    }
+    throw new Error('cannot figure out how to load external JS scripts in this environment');
+}
+export function isCJSPluginDefinition(def) {
+    return def.cjsUrl !== undefined;
+}
+export function pluginDescriptionString(d) {
+    if (isUMDPluginDefinition(d)) {
+        return `UMD plugin ${d.name}`;
+    }
+    else if (isESMPluginDefinition(d)) {
+        return `ESM plugin ${d.esmUrl ||
+            d.esmLoc.uri}`;
+    }
+    else if (isCJSPluginDefinition(d)) {
+        return `CJS plugin ${d.cjsUrl}`;
+    }
+    else {
+        return 'unknown plugin';
+    }
+}
+export function pluginUrl(d) {
+    if (isUMDPluginDefinition(d)) {
+        return d.url ?? d.umdLoc?.uri ?? d.umdUrl;
+    }
+    else if (isESMPluginDefinition(d)) {
+        return d.esmUrl ?? d.esmUri ?? d.esmLoc?.uri;
+    }
+    else if (isCJSPluginDefinition(d)) {
+        return d.cjsUrl || d.cjsLoc.uri;
+    }
+    else {
+        return 'unknown url';
+    }
+}
+function isInWebWorker() {
+    return 'WorkerGlobalScope' in globalThis;
+}
+export default class PluginLoader {
+    definitions = [];
+    fetchESM;
+    fetchCJS;
+    constructor(defs = [], args) {
+        this.fetchESM = args?.fetchESM;
+        this.fetchCJS = args?.fetchCJS;
+        this.definitions = JSON.parse(JSON.stringify(defs));
+    }
+    async loadCJSPlugin(def, baseUri) {
+        const parsedUrl = new URL(def.cjsUrl, baseUri);
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            throw new Error(`Cannot load plugins using protocol "${parsedUrl.protocol}"`);
+        }
+        if (!this.fetchCJS) {
+            throw new Error('No fetchCJS callback provided');
+        }
+        return this.fetchCJS(parsedUrl.href);
+    }
+    async loadESMPlugin(def, baseUri) {
+        const parsedUrl = 'esmUrl' in def
+            ? new URL(def.esmUrl, baseUri)
+            : 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}"`);
+        }
+        if (!this.fetchESM) {
+            throw new Error('No ESM fetcher installed');
+        }
+        const plugin = await this.fetchESM(parsedUrl.href);
+        if (!plugin) {
+            throw new Error(`Could not load ESM plugin: ${parsedUrl}`);
+        }
+        return plugin;
+    }
+    async loadUMDPlugin(def, baseUri) {
+        const parsedUrl = 'url' in def
+            ? new URL(def.url, baseUri)
+            : 'umdUrl' in def
+                ? new URL(def.umdUrl, baseUri)
+                : 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}"`);
+        }
+        const moduleName = def.name;
+        const umdName = `JBrowsePlugin${moduleName}`;
+        if (typeof jest === 'undefined') {
+            await loadScript(parsedUrl.href);
+        }
+        else {
+            globalThis[umdName] = { default: Plugin };
+        }
+        const plugin = globalThis[umdName];
+        if (!plugin) {
+            throw new Error(`Failed to load UMD bundle for ${moduleName}, ${umdName} is undefined`);
+        }
+        return plugin;
+    }
+    async loadPlugin(def, baseUri) {
+        let plugin;
+        if (isElectron && isCJSPluginDefinition(def)) {
+            plugin = await this.loadCJSPlugin(def, baseUri);
+        }
+        else if (isESMPluginDefinition(def)) {
+            plugin = await this.loadESMPlugin(def, baseUri);
+        }
+        else if (isUMDPluginDefinition(def)) {
+            plugin = await this.loadUMDPlugin(def, baseUri);
+        }
+        else if (!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(def)}`);
+        }
+        if (!plugin.default) {
+            throw new Error(`${pluginDescriptionString(def)} does not have a default export, cannot load`);
+        }
+        return plugin.default;
+    }
+    installGlobalReExports(target) {
+        target.JBrowseExports = Object.fromEntries(Object.entries(ReExports).map(([moduleName, module]) => {
+            return [moduleName, module];
+        }));
+        return this;
+    }
+    async load(baseUri) {
+        return Promise.all(this.definitions.map(async (definition) => ({
+            plugin: await this.loadPlugin(definition, baseUri),
+            definition,
+        })));
+    }
+}

package/esm/PluginManager.d.ts

@@ -0,0 +1,125 @@
+import PhasedScheduler from './PhasedScheduler.ts';
+import ReExports from './ReExports/index.ts';
+import AdapterType from './pluggableElementTypes/AdapterType.ts';
+import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType.ts';
+import ConnectionType from './pluggableElementTypes/ConnectionType.ts';
+import DisplayType from './pluggableElementTypes/DisplayType.ts';
+import GlyphType from './pluggableElementTypes/GlyphType.ts';
+import InternetAccountType from './pluggableElementTypes/InternetAccountType.ts';
+import RpcMethodType from './pluggableElementTypes/RpcMethodType.ts';
+import TextSearchAdapterType from './pluggableElementTypes/TextSearchAdapterType.ts';
+import TrackType from './pluggableElementTypes/TrackType.ts';
+import ViewType from './pluggableElementTypes/ViewType.ts';
+import WidgetType from './pluggableElementTypes/WidgetType.ts';
+import RendererType from './pluggableElementTypes/renderers/RendererType.tsx';
+import type Plugin from './Plugin.ts';
+import type { PluginDefinition } from './PluginLoader.ts';
+import type PluggableElementBase from './pluggableElementTypes/PluggableElementBase.ts';
+import type { PluggableElementType } from './pluggableElementTypes/index.ts';
+import type { AbstractRootModel } from './util/index.ts';
+import type { IAnyModelType, IAnyType } from '@jbrowse/mobx-state-tree';
+type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow' | 'glyph';
+declare class TypeRecord<ElementClass extends PluggableElementBase> {
+    typeName: string;
+    baseClass: (new (...args: unknown[]) => ElementClass) | (Function & {
+        prototype: ElementClass;
+    });
+    registeredTypes: Record<string, ElementClass>;
+    constructor(typeName: string, baseClass: (new (...args: unknown[]) => ElementClass) | (Function & {
+        prototype: ElementClass;
+    }));
+    add(name: string, t: ElementClass): void;
+    has(name: string): boolean;
+    get(name: string): ElementClass | undefined;
+    all(): ElementClass[];
+}
+type AnyFunction = (...args: any) => any;
+export type PluginMetadata = Record<string, unknown>;
+export interface PluginLoadRecord {
+    metadata?: PluginMetadata;
+    plugin: Plugin;
+}
+export interface RuntimePluginLoadRecord extends PluginLoadRecord {
+    definition: PluginDefinition;
+}
+export default class PluginManager {
+    plugins: Plugin[];
+    jexl: import("@jbrowse/jexl").Jexl;
+    pluginMetadata: Record<string, PluginMetadata>;
+    runtimePluginDefinitions: PluginDefinition[];
+    elementCreationSchedule: PhasedScheduler<PluggableElementTypeGroup> | undefined;
+    glyphTypes: TypeRecord<GlyphType>;
+    rendererTypes: TypeRecord<RendererType>;
+    adapterTypes: TypeRecord<AdapterType>;
+    textSearchAdapterTypes: TypeRecord<TextSearchAdapterType>;
+    trackTypes: TypeRecord<TrackType>;
+    displayTypes: TypeRecord<DisplayType>;
+    connectionTypes: TypeRecord<ConnectionType>;
+    viewTypes: TypeRecord<ViewType>;
+    widgetTypes: TypeRecord<WidgetType>;
+    rpcMethods: TypeRecord<RpcMethodType>;
+    addTrackWidgets: TypeRecord<AddTrackWorkflowType>;
+    internetAccountTypes: TypeRecord<InternetAccountType>;
+    configured: boolean;
+    rootModel?: AbstractRootModel;
+    extensionPoints: Map<string, Function[]>;
+    constructor(initialPlugins?: (Plugin | PluginLoadRecord)[]);
+    pluginConfigurationNamespacedSchemas(): Record<string, unknown>;
+    pluginConfigurationUnnamespacedSchemas(): Record<string, unknown>;
+    pluginConfigurationRootSchemas(): Record<string, unknown>;
+    addPlugin(load: Plugin | PluginLoadRecord | RuntimePluginLoadRecord): this;
+    getPlugin(name: string): Plugin | undefined;
+    hasPlugin(name: string): boolean;
+    createPluggableElements(): this;
+    setRootModel(rootModel: AbstractRootModel): this;
+    configure(): this;
+    getElementTypeRecord(groupName: PluggableElementTypeGroup): TypeRecord<PluggableElementBase>;
+    addElementType(groupName: PluggableElementTypeGroup, creationCallback: (pluginManager: PluginManager) => PluggableElementType): this;
+    getElementType(groupName: PluggableElementTypeGroup, typeName: string): PluggableElementBase | undefined;
+    getElementTypesInGroup(groupName: PluggableElementTypeGroup): PluggableElementBase[];
+    getViewElements(): ViewType[];
+    getTrackElements(): TrackType[];
+    getConnectionElements(): ConnectionType[];
+    getAddTrackWorkflowElements(): AddTrackWorkflowType[];
+    getRpcElements(): RpcMethodType[];
+    getDisplayElements(): DisplayType[];
+    getAdapterElements(): AdapterType[];
+    pluggableMstType(groupName: PluggableElementTypeGroup, fieldName: string, fallback?: IAnyType): IAnyType;
+    pluggableConfigSchemaType(typeGroup: PluggableElementTypeGroup, fieldName?: string): IAnyModelType;
+    jbrequireCache: Map<any, any>;
+    lib: any;
+    load: <FTYPE extends AnyFunction>(lib: FTYPE) => ReturnType<FTYPE>;
+    jbrequire: (lib: keyof typeof ReExports | AnyFunction | {
+        default: AnyFunction;
+    }) => any;
+    getRendererType(typeName: string): RendererType | undefined;
+    getRendererTypes(): RendererType[];
+    getAdapterType(typeName: string): AdapterType | undefined;
+    getTextSearchAdapterType(typeName: string): TextSearchAdapterType | undefined;
+    getTrackType(typeName: string): TrackType | undefined;
+    getDisplayType(typeName: string): DisplayType | undefined;
+    getViewType(typeName: string): ViewType | undefined;
+    getAddTrackWorkflow(typeName: string): AddTrackWorkflowType | undefined;
+    getWidgetType(typeName: string): WidgetType | undefined;
+    getConnectionType(typeName: string): ConnectionType | undefined;
+    getRpcMethodType(methodName: string): RpcMethodType | undefined;
+    getInternetAccountType(name: string): InternetAccountType | undefined;
+    addRendererType(cb: (pm: PluginManager) => RendererType): this;
+    addAdapterType(cb: (pm: PluginManager) => AdapterType): this;
+    addTextSearchAdapterType(cb: (pm: PluginManager) => TextSearchAdapterType): this;
+    addTrackType(cb: (pm: PluginManager) => TrackType): this;
+    addDisplayType(cb: (pluginManager: PluginManager) => DisplayType): this;
+    addViewType(cb: (pluginManager: PluginManager) => ViewType): this;
+    addWidgetType(cb: (pm: PluginManager) => WidgetType): this;
+    addConnectionType(cb: (pm: PluginManager) => ConnectionType): this;
+    addRpcMethod(cb: (pm: PluginManager) => RpcMethodType): this;
+    addInternetAccountType(cb: (pm: PluginManager) => InternetAccountType): this;
+    addAddTrackWorkflowType(cb: (pm: PluginManager) => AddTrackWorkflowType): this;
+    addGlyphType(cb: (pm: PluginManager) => GlyphType): this;
+    getGlyphType(typeName: string): GlyphType | undefined;
+    getGlyphTypes(): GlyphType[];
+    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 {};