@jbrowse/core 3.7.0 → 4.0.0

package/Plugin.d.ts

@@ -1,13 +0,0 @@
-import type PluginManager from './PluginManager';
-import type { AnyConfigurationSchemaType } from './configuration';
-export default abstract class Plugin {
-    abstract name: string;
-    url?: string;
-    version?: string;
-    install(_pluginManager: PluginManager): void;
-    configure(_pluginManager: PluginManager): void;
-    configurationSchema?: AnyConfigurationSchemaType;
-    configurationSchemaUnnamespaced?: AnyConfigurationSchemaType;
-    rootConfigurationSchema?: (arg: PluginManager) => Record<string, AnyConfigurationSchemaType>;
-}
-export type PluginConstructor = new (...args: unknown[]) => Plugin;

package/Plugin.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Plugin {
-    install(_pluginManager) { }
-    configure(_pluginManager) { }
-}
-exports.default = Plugin;

package/PluginLoader.d.ts

@@ -1,64 +0,0 @@
-import type { PluginConstructor } from './Plugin';
-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/PluginLoader.js

@@ -1,174 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUMDPluginDefinition = isUMDPluginDefinition;
-exports.isESMPluginDefinition = isESMPluginDefinition;
-exports.isCJSPluginDefinition = isCJSPluginDefinition;
-exports.pluginDescriptionString = pluginDescriptionString;
-exports.pluginUrl = pluginUrl;
-const load_script_1 = __importDefault(require("load-script"));
-const Plugin_1 = __importDefault(require("./Plugin"));
-const ReExports_1 = __importDefault(require("./ReExports"));
-const util_1 = require("./util");
-function isUMDPluginDefinition(def) {
-    return ((def.umdUrl !== undefined ||
-        def.url !== undefined ||
-        def.umdLoc !== undefined) &&
-        def.name !== undefined);
-}
-function isESMPluginDefinition(def) {
-    return (def.esmUrl !== undefined ||
-        def.esmLoc !== undefined);
-}
-function promisifiedLoadScript(src) {
-    return new Promise((resolve, reject) => {
-        (0, load_script_1.default)(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');
-}
-function isCJSPluginDefinition(def) {
-    return def.cjsUrl !== undefined;
-}
-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';
-    }
-}
-function pluginUrl(d) {
-    var _a, _b, _c, _d, _e, _f;
-    if (isUMDPluginDefinition(d)) {
-        return (_c = (_a = d.url) !== null && _a !== void 0 ? _a : (_b = d.umdLoc) === null || _b === void 0 ? void 0 : _b.uri) !== null && _c !== void 0 ? _c : d.umdUrl;
-    }
-    else if (isESMPluginDefinition(d)) {
-        return (_e = (_d = d.esmUrl) !== null && _d !== void 0 ? _d : d.esmUri) !== null && _e !== void 0 ? _e : (_f = d.esmLoc) === null || _f === void 0 ? void 0 : _f.uri;
-    }
-    else if (isCJSPluginDefinition(d)) {
-        return d.cjsUrl || d.cjsLoc.uri;
-    }
-    else {
-        return 'unknown url';
-    }
-}
-function isInWebWorker() {
-    return 'WorkerGlobalScope' in globalThis;
-}
-class PluginLoader {
-    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(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_1.default };
-        }
-        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 (util_1.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 (!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(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_1.default).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,
-        })));
-    }
-}
-exports.default = PluginLoader;

package/PluginManager.d.ts

@@ -1,139 +0,0 @@
-import PhasedScheduler from './PhasedScheduler';
-import ReExports from './ReExports';
-import AdapterType from './pluggableElementTypes/AdapterType';
-import AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType';
-import ConnectionType from './pluggableElementTypes/ConnectionType';
-import DisplayType from './pluggableElementTypes/DisplayType';
-import InternetAccountType from './pluggableElementTypes/InternetAccountType';
-import RpcMethodType from './pluggableElementTypes/RpcMethodType';
-import TextSearchAdapterType from './pluggableElementTypes/TextSearchAdapterType';
-import TrackType from './pluggableElementTypes/TrackType';
-import ViewType from './pluggableElementTypes/ViewType';
-import WidgetType from './pluggableElementTypes/WidgetType';
-import RendererType from './pluggableElementTypes/renderers/RendererType';
-import type Plugin from './Plugin';
-import type { PluginDefinition } from './PluginLoader';
-import type { PluggableElementMember, PluggableElementType } from './pluggableElementTypes';
-import type PluggableElementBase from './pluggableElementTypes/PluggableElementBase';
-import type { AbstractRootModel } from './util';
-import type { IAnyModelType, IAnyType } from 'mobx-state-tree';
-type PluggableElementTypeGroup = 'renderer' | 'adapter' | 'display' | 'track' | 'connection' | 'view' | 'widget' | 'rpc method' | 'internet account' | 'text search adapter' | 'add track workflow';
-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: {
-        addBinaryOp: (operator: string, precedence: number, fn: (left: any, right: any) => any) => void;
-        addUnaryOp: (operator: string, fn: (right: any) => any) => void;
-        addTransform: (name: string, fn: (value: any, ...args: any[]) => any) => void;
-        addTransforms: (map: {
-            [key: string]: (value: any, ...args: any[]) => any;
-        }) => void;
-        getTransform: (name: string) => (value: any, ...args: any[]) => any;
-        addFunction: (name: string, fn: (value: any, ...args: any[]) => any) => void;
-        addFunctions: (map: {
-            [key: string]: (value: any, ...args: any[]) => any;
-        }) => void;
-        getFunction: (name: string) => (value: any, ...args: any[]) => any;
-        eval: (expression: string, context?: import("jexl/Expression").Context) => Promise<any>;
-        evalSync: (expression: string, context?: import("jexl/Expression").Context) => any;
-        compile: (expression: string) => import("jexl/Expression").default;
-        createExpression: (expression: string) => import("jexl/Expression").default;
-        removeOp: (operator: string) => void;
-        _grammar: import("jexl/Grammar").default;
-    };
-    pluginMetadata: Record<string, PluginMetadata>;
-    runtimePluginDefinitions: PluginDefinition[];
-    elementCreationSchedule: PhasedScheduler<PluggableElementTypeGroup> | undefined;
-    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: PluggableElementMember, fallback?: IAnyType): IAnyType;
-    pluggableConfigSchemaType(typeGroup: PluggableElementTypeGroup, fieldName?: PluggableElementMember): 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;
-    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 {};