@jbrowse/core 2.17.0 → 2.18.0

package/data_adapters/dataAdapterCache.d.ts

@@ -1,31 +1,14 @@
-import { SnapshotIn } from 'mobx-state-tree';
-import PluginManager from '../PluginManager';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyDataAdapter } from './BaseAdapter';
+import type PluginManager from '../PluginManager';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyDataAdapter } from './BaseAdapter';
+import type { SnapshotIn } from 'mobx-state-tree';
 type ConfigSnap = SnapshotIn<AnyConfigurationSchemaType>;
 export declare function adapterConfigCacheKey(conf?: Record<string, unknown>): string;
 interface AdapterCacheEntry {
     dataAdapter: AnyDataAdapter;
     sessionIds: Set<string>;
 }
-/**
- * instantiate a data adapter, or return an already-instantiated one if we have
- * one with the same configuration
- *
- * @param pluginManager
- *
- * @param sessionId - session ID of the associated worker session. used for
- * reference counting
- *
- * @param adapterConfigSnapshot - plain-JS configuration snapshot for the
- * adapter
- */
 export declare function getAdapter(pluginManager: PluginManager, sessionId: string, adapterConfigSnapshot: SnapshotIn<AnyConfigurationSchemaType>): Promise<AdapterCacheEntry>;
-/**
- * this is a callback that is passed to adapters that
- * allows them to get any sub-adapters that they need
- * internally, staying with the same worker session ID
- */
 export type getSubAdapterType = (adapterConfigSnap: ConfigSnap) => ReturnType<typeof getAdapter>;
 export declare function freeAdapterResources(specification: Record<string, any>): number;
 export declare function clearAdapterCache(): void;

package/data_adapters/dataAdapterCache.js

@@ -12,20 +12,7 @@ function adapterConfigCacheKey(conf = {}) {
     return `${(0, idMaker_1.default)(conf)}`;
 }
 let adapterCache = {};
-/**
- * instantiate a data adapter, or return an already-instantiated one if we have
- * one with the same configuration
- *
- * @param pluginManager
- *
- * @param sessionId - session ID of the associated worker session. used for
- * reference counting
- *
- * @param adapterConfigSnapshot - plain-JS configuration snapshot for the
- * adapter
- */
 async function getAdapter(pluginManager, sessionId, adapterConfigSnapshot) {
-    // cache the adapter object
     const cacheKey = adapterConfigCacheKey(adapterConfigSnapshot);
     if (!adapterCache[cacheKey]) {
         const adapterType = adapterConfigSnapshot === null || adapterConfigSnapshot === void 0 ? void 0 : adapterConfigSnapshot.type;
@@ -36,13 +23,10 @@ async function getAdapter(pluginManager, sessionId, adapterConfigSnapshot) {
         if (!dataAdapterType) {
             throw new Error(`unknown data adapter type ${adapterType}`);
         }
-        // instantiate the data adapter's config schema so it gets its defaults,
-        // callbacks, etc
         const adapterConfig = dataAdapterType.configSchema.create(adapterConfigSnapshot, { pluginManager });
         const getSubAdapter = getAdapter.bind(null, pluginManager, sessionId);
         const CLASS = await dataAdapterType.getAdapterClass();
         const dataAdapter = new CLASS(adapterConfig, getSubAdapter, pluginManager);
-        // store it in our cache
         adapterCache[cacheKey] = {
             dataAdapter,
             sessionIds: new Set([sessionId]),
@@ -55,8 +39,6 @@ async function getAdapter(pluginManager, sessionId, adapterConfigSnapshot) {
 function freeAdapterResources(specification) {
     let deleteCount = 0;
     const specKeys = Object.keys(specification);
-    // if we don't specify a range, delete any adapters that are only associated
-    // with that session
     if (specKeys.length === 1 && specKeys[0] === 'sessionId') {
         const { sessionId } = specification;
         Object.entries(adapterCache).forEach(([cacheKey, cacheEntry]) => {
@@ -68,7 +50,6 @@ function freeAdapterResources(specification) {
         });
     }
     else {
-        // otherwise call freeResources on all the cached data adapters
         Object.values(adapterCache).forEach(cacheEntry => {
             const regions = specification.regions ||
                 (specification.region ? [specification.region] : []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
     "jbrowse",
@@ -31,15 +31,14 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.17.9",
+    "@floating-ui/react": "^0.27.0",
     "@gmod/abortable-promise-cache": "^2.0.0",
     "@gmod/bgzf-filehandle": "^1.4.3",
     "@gmod/http-range-fetcher": "^3.0.4",
     "@mui/icons-material": "^6.0.0",
     "@mui/x-data-grid": "^7.0.0",
-    "@types/clone": "^2.0.0",
     "canvas-sequencer": "^3.1.0",
     "canvas2svg": "^1.0.16",
-    "clone": "^2.1.2",
     "colord": "^2.9.3",
     "copy-to-clipboard": "^3.3.1",
     "deepmerge": "^4.2.2",
@@ -72,5 +71,5 @@
     "access": "public",
     "directory": "dist"
   },
-  "gitHead": "eed30b5e671f8f7823652d7cecc51aa89226de46"
+  "gitHead": "c344ea60099cb7e460b77f15808946b24a7eee74"
 }

package/pluggableElementTypes/AdapterType.d.ts

@@ -1,6 +1,6 @@
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyAdapter } from '../data_adapters/BaseAdapter';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyAdapter } from '../data_adapters/BaseAdapter';
 export interface AdapterMetadata {
     category?: string;
     hiddenFromGUI?: boolean;

package/pluggableElementTypes/AddTrackWorkflowType.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
-import { IAnyModelType } from 'mobx-state-tree';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
+import type { IAnyModelType } from 'mobx-state-tree';
 type BasicComponent = React.ComponentType<{
     model: any;
 }>;

package/pluggableElementTypes/ConnectionType.d.ts

@@ -1,7 +1,7 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyReactComponentType } from '../util';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyReactComponentType } from '../util';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class ConnectionType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/DisplayType.d.ts

@@ -1,22 +1,16 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyReactComponentType } from '../util';
-import { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyReactComponentType } from '../util';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class DisplayType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;
     ReactComponent: AnyReactComponentType;
-    /**
-     * The track type the display is associated with
-     */
     trackType: string;
     subDisplay?: {
         type: string;
         [key: string]: unknown;
     };
-    /**
-     * The view type the display is associated with
-     */
     viewType: string;
     constructor(stuff: {
         name: string;

package/pluggableElementTypes/InternetAccountType.d.ts

@@ -1,6 +1,6 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration/types';
+import type { AnyConfigurationSchemaType } from '../configuration/types';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class InternetAccountType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/PluggableElementBase.d.ts

@@ -1,7 +1,7 @@
 export default abstract class PluggableElementBase {
     name: string;
     maybeDisplayName?: string;
-    constructor(args: {
+    constructor(args?: {
         name?: string;
         displayName?: string;
     });

package/pluggableElementTypes/PluggableElementBase.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 class PluggableElementBase {
     constructor(args) {
-        this.name = args.name || 'UNKNOWN';
-        this.maybeDisplayName = args.displayName;
+        this.name = (args === null || args === void 0 ? void 0 : args.name) || 'UNKNOWN';
+        this.maybeDisplayName = args === null || args === void 0 ? void 0 : args.displayName;
     }
     get displayName() {
         return this.maybeDisplayName || this.name;

package/pluggableElementTypes/RpcMethodType.d.ts

@@ -1,23 +1,17 @@
-import PluginManager from '../PluginManager';
 import PluggableElementBase from './PluggableElementBase';
-import { UriLocation } from '../util/types';
-import { RemoteAbortSignal } from '../rpc/remoteAbortSignals';
-interface SerializedArgs {
-    signal?: RemoteAbortSignal;
-    blobMap?: Record<string, File>;
-}
+import type PluginManager from '../PluginManager';
+import type { UriLocation } from '../util/types';
 export type RpcMethodConstructor = new (pm: PluginManager) => RpcMethodType;
 export default abstract class RpcMethodType extends PluggableElementBase {
     pluginManager: PluginManager;
     constructor(pluginManager: PluginManager);
     serializeArguments(args: Record<string, unknown>, rpcDriverClassName: string): Promise<Record<string, unknown>>;
     serializeNewAuthArguments(loc: UriLocation, rpcDriverClassName: string): Promise<UriLocation>;
-    deserializeArguments<T extends SerializedArgs>(serializedArgs: T, _rpcDriverClassName: string): Promise<T & {
-        signal: AbortSignal | undefined;
-    }>;
+    deserializeArguments<T>(args: T & {
+        blobMap?: Record<string, File>;
+    }, _rpcDriverClassName: string): Promise<T>;
     abstract execute(serializedArgs: unknown, rpcDriverClassName: string): Promise<unknown>;
     serializeReturn(originalReturn: unknown, _args: unknown, _rpcDriverClassName: string): Promise<unknown>;
     deserializeReturn(serializedReturn: unknown, _args: unknown, _rpcDriverClassName: string): Promise<unknown>;
     private augmentLocationObjects;
 }
-export {};

package/pluggableElementTypes/RpcMethodType.js

@@ -3,14 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const map_obj_1 = __importDefault(require("../util/map-obj"));
 const PluggableElementBase_1 = __importDefault(require("./PluggableElementBase"));
+const map_obj_1 = __importDefault(require("../util/map-obj"));
 const tracks_1 = require("../util/tracks");
 const types_1 = require("../util/types");
-const remoteAbortSignals_1 = require("../rpc/remoteAbortSignals");
 class RpcMethodType extends PluggableElementBase_1.default {
     constructor(pluginManager) {
-        super({});
+        super();
         this.pluginManager = pluginManager;
     }
     async serializeArguments(args, rpcDriverClassName) {
@@ -20,30 +19,21 @@ class RpcMethodType extends PluggableElementBase_1.default {
     }
     async serializeNewAuthArguments(loc, rpcDriverClassName) {
         const rootModel = this.pluginManager.rootModel;
-        // args dont need auth or already have auth
         if (!(0, types_1.isAppRootModel)(rootModel) || loc.internetAccountPreAuthorization) {
             return loc;
         }
         const account = rootModel.findAppropriateInternetAccount(loc);
-        // mutating loc object is not allowed in MainThreadRpcDriver, and is only
-        // needed for web worker RPC
         if (account && rpcDriverClassName !== 'MainThreadRpcDriver') {
             loc.internetAccountPreAuthorization =
                 await account.getPreAuthorizationInformation(loc);
         }
         return loc;
     }
-    async deserializeArguments(serializedArgs, _rpcDriverClassName) {
-        if (serializedArgs.blobMap) {
-            (0, tracks_1.setBlobMap)(serializedArgs.blobMap);
+    async deserializeArguments(args, _rpcDriverClassName) {
+        if (args.blobMap) {
+            (0, tracks_1.setBlobMap)(args.blobMap);
         }
-        const { signal } = serializedArgs;
-        return {
-            ...serializedArgs,
-            signal: (0, remoteAbortSignals_1.isRemoteAbortSignal)(signal)
-                ? (0, remoteAbortSignals_1.deserializeAbortSignal)(signal)
-                : undefined,
-        };
+        return args;
     }
     async serializeReturn(originalReturn, _args, _rpcDriverClassName) {
         return originalReturn;
@@ -56,8 +46,7 @@ class RpcMethodType extends PluggableElementBase_1.default {
         }
         catch (error) {
             if ((0, types_1.isAuthNeededException)(error)) {
-                const retryAccount = // @ts-expect-error
-                 (_a = this.pluginManager.rootModel) === null || _a === void 0 ? void 0 : _a.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
+                const retryAccount = (_a = this.pluginManager.rootModel) === null || _a === void 0 ? void 0 : _a.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
                 throw new types_1.RetryError('Retrying with created internet account', retryAccount.internetAccountId);
             }
             throw error;
@@ -66,7 +55,6 @@ class RpcMethodType extends PluggableElementBase_1.default {
     }
     async augmentLocationObjects(thing, rpcDriverClassName) {
         const uris = [];
-        // using map-obj avoids cycles, seen in circular view svg export
         (0, map_obj_1.default)(thing, val => {
             if ((0, types_1.isUriLocation)(val)) {
                 uris.push(val);

package/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.d.ts

@@ -0,0 +1,9 @@
+import RpcMethodType from './RpcMethodType';
+import type { RenderArgs } from '@jbrowse/core/rpc/coreRpcMethods';
+export default abstract class RpcMethodTypeWithFiltersAndRenameRegions extends RpcMethodType {
+    deserializeArguments(args: any, rpcDriverClassName: string): Promise<any>;
+    serializeArguments(args: RenderArgs & {
+        stopToken?: string;
+        statusCallback?: (arg: string) => void;
+    }, rpcDriverClassName: string): Promise<Record<string, unknown>>;
+}

package/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RpcMethodType_1 = __importDefault(require("./RpcMethodType"));
+const util_1 = require("../util");
+const serializableFilterChain_1 = __importDefault(require("./renderers/util/serializableFilterChain"));
+class RpcMethodTypeWithFiltersAndRenameRegions extends RpcMethodType_1.default {
+    async deserializeArguments(args, rpcDriverClassName) {
+        const l = await super.deserializeArguments(args, rpcDriverClassName);
+        return {
+            ...l,
+            filters: args.filters
+                ? new serializableFilterChain_1.default({
+                    filters: args.filters,
+                })
+                : undefined,
+        };
+    }
+    async serializeArguments(args, rpcDriverClassName) {
+        var _a, _b, _c;
+        const pm = this.pluginManager;
+        const assemblyManager = (_b = (_a = pm.rootModel) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.assemblyManager;
+        if (!assemblyManager) {
+            throw new Error('no assembly manager');
+        }
+        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, {
+            ...args,
+            filters: (_c = args.filters) === null || _c === void 0 ? void 0 : _c.toJSON().filters,
+        });
+        return super.serializeArguments(renamedArgs, rpcDriverClassName);
+    }
+}
+exports.default = RpcMethodTypeWithFiltersAndRenameRegions;

package/pluggableElementTypes/TextSearchAdapterType.d.ts

@@ -1,6 +1,6 @@
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import { AnyAdapter } from '../data_adapters/BaseAdapter';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyAdapter } from '../data_adapters/BaseAdapter';
 export default class TextSearchAdapterType extends PluggableElementBase {
     getAdapterClass: () => Promise<AnyAdapter>;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/TrackType.d.ts

@@ -1,7 +1,7 @@
-import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
-import DisplayType from './DisplayType';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type DisplayType from './DisplayType';
+import type { IAnyModelType } from 'mobx-state-tree';
 export default class TrackType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;

package/pluggableElementTypes/ViewType.d.ts

@@ -1,7 +1,7 @@
-import React from 'react';
-import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
-import DisplayType from './DisplayType';
+import type DisplayType from './DisplayType';
+import type { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 type BasicView = React.ComponentType<{
     model: any;
     session?: IAnyStateTreeNode;

package/pluggableElementTypes/WidgetType.d.ts

@@ -1,7 +1,8 @@
-import React, { ComponentType, LazyExoticComponent } from 'react';
-import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
+import type { ComponentType, LazyExoticComponent } from 'react';
+import type React from 'react';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration';
+import type { AnyConfigurationSchemaType } from '../configuration';
+import type { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 type WidgetComponentType = LazyExoticComponent<React.FC<any>> | React.FC<any>;
 type HeadingComponentType = ComponentType<{
     model: IAnyStateTreeNode;

package/pluggableElementTypes/index.d.ts

@@ -1,14 +1,14 @@
-import AdapterType from './AdapterType';
-import ConnectionType from './ConnectionType';
-import RendererType from './renderers/RendererType';
-import WidgetType from './WidgetType';
-import TrackType from './TrackType';
-import DisplayType from './DisplayType';
-import ViewType from './ViewType';
-import RpcMethodType from './RpcMethodType';
-import InternetAccountType from './InternetAccountType';
-import TextSearchAdapterType from './TextSearchAdapterType';
-import AddTrackWorkflowType from './AddTrackWorkflowType';
+import type AdapterType from './AdapterType';
+import type AddTrackWorkflowType from './AddTrackWorkflowType';
+import type ConnectionType from './ConnectionType';
+import type DisplayType from './DisplayType';
+import type InternetAccountType from './InternetAccountType';
+import type RpcMethodType from './RpcMethodType';
+import type TextSearchAdapterType from './TextSearchAdapterType';
+import type TrackType from './TrackType';
+import type ViewType from './ViewType';
+import type WidgetType from './WidgetType';
+import type RendererType from './renderers/RendererType';
 export * from './renderers';
 export * from './models';
 export type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;

package/pluggableElementTypes/models/BaseConnectionModelFactory.d.ts

@@ -1,21 +1,9 @@
-import { AnyConfigurationModel } from '../../configuration';
-import PluginManager from '../../PluginManager';
+import type PluginManager from '../../PluginManager';
+import type { AnyConfigurationModel } from '../../configuration';
 type TrackConf = AnyConfigurationModel | Record<string, unknown>;
-/**
- * #stateModel BaseConnectionModel
- */
 declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
-    /**
-     * #property
-     */
     name: import("mobx-state-tree").ISimpleType<string>;
-    /**
-     * #property
-     */
     tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>;
-    /**
-     * #property
-     */
     configuration: import("../../configuration/configurationSchema").ConfigurationSchemaType<{
         name: {
             type: string;
@@ -29,27 +17,12 @@ declare function stateModelFactory(pluginManager: PluginManager): import("mobx-s
         };
     }, import("../../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>;
 }, {
-    /**
-     * #action
-     */
     connect(_arg: AnyConfigurationModel): void;
 } & {
     afterAttach(): void;
-    /**
-     * #action
-     */
     addTrackConf(trackConf: TrackConf): any;
-    /**
-     * #action
-     */
     addTrackConfs(trackConfs: TrackConf[]): void;
-    /**
-     * #action
-     */
     setTrackConfs(trackConfs: AnyConfigurationModel[]): void;
-    /**
-     * #action
-     */
     clear(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type BaseConnectionModel = ReturnType<typeof stateModelFactory>;

package/pluggableElementTypes/models/BaseConnectionModelFactory.js

@@ -4,31 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("../../configuration");
 const baseConnectionConfig_1 = __importDefault(require("./baseConnectionConfig"));
-/**
- * #stateModel BaseConnectionModel
- */
+const configuration_1 = require("../../configuration");
 function stateModelFactory(pluginManager) {
     return mobx_state_tree_1.types
         .model('Connection', {
-        /**
-         * #property
-         */
         name: mobx_state_tree_1.types.identifier,
-        /**
-         * #property
-         */
         tracks: mobx_state_tree_1.types.array(pluginManager.pluggableConfigSchemaType('track')),
-        /**
-         * #property
-         */
         configuration: (0, configuration_1.ConfigurationReference)(baseConnectionConfig_1.default),
     })
         .actions(() => ({
-        /**
-         * #action
-         */
         connect(_arg) { },
     }))
         .actions(self => ({
@@ -37,28 +22,16 @@ function stateModelFactory(pluginManager) {
                 self.connect(self.configuration);
             }
         },
-        /**
-         * #action
-         */
         addTrackConf(trackConf) {
             const length = self.tracks.push(trackConf);
             return self.tracks[length - 1];
         },
-        /**
-         * #action
-         */
         addTrackConfs(trackConfs) {
             self.tracks.push(...trackConfs);
         },
-        /**
-         * #action
-         */
         setTrackConfs(trackConfs) {
             self.tracks = (0, mobx_state_tree_1.cast)(trackConfs);
         },
-        /**
-         * #action
-         */
         clear() { },
     }));
 }