@jbrowse/core 2.13.1 → 2.15.0

package/rpc/RpcManager.js

@@ -7,6 +7,7 @@ const configuration_1 = require("../configuration");
 const configSchema_1 = __importDefault(require("./configSchema"));
 const WebWorkerRpcDriver_1 = __importDefault(require("./WebWorkerRpcDriver"));
 const MainThreadRpcDriver_1 = __importDefault(require("./MainThreadRpcDriver"));
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const DriverClasses = {
     WebWorkerRpcDriver: WebWorkerRpcDriver_1.default,
     MainThreadRpcDriver: MainThreadRpcDriver_1.default,
@@ -16,9 +17,6 @@ class RpcManager {
         this.pluginManager = pluginManager;
         this.mainConfiguration = mainConfiguration;
         this.backendConfigurations = backendConfigurations;
-        if (!mainConfiguration) {
-            throw new Error('RpcManager requires at least a main configuration');
-        }
         this.driverObjects = new Map();
     }
     getDriver(backendName) {
@@ -26,30 +24,35 @@ class RpcManager {
         if (driver) {
             return driver;
         }
-        let newDriver;
         const config = this.mainConfiguration.drivers.get('WebWorkerRpcDriver');
         if (backendName === 'MainThreadRpcDriver') {
             const backendConfiguration = this.backendConfigurations.MainThreadRpcDriver;
             if (!backendConfiguration) {
                 throw new Error(`requested RPC driver "${backendName}" is missing config`);
             }
-            newDriver = new MainThreadRpcDriver_1.default({ ...backendConfiguration, config });
+            const newDriver = new MainThreadRpcDriver_1.default({
+                ...backendConfiguration,
+                config,
+            });
+            this.driverObjects.set(backendName, newDriver);
+            return newDriver;
         }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         else if (backendName === 'WebWorkerRpcDriver') {
             const backendConfiguration = this.backendConfigurations.WebWorkerRpcDriver;
             if (!backendConfiguration) {
                 throw new Error(`requested RPC driver "${backendName}" is missing config`);
             }
-            newDriver = new WebWorkerRpcDriver_1.default({ ...backendConfiguration, config }, {
+            const newDriver = new WebWorkerRpcDriver_1.default({ ...backendConfiguration, config }, {
                 plugins: this.pluginManager.runtimePluginDefinitions,
                 windowHref: window.location.href,
             });
+            this.driverObjects.set(backendName, newDriver);
+            return newDriver;
         }
         else {
             throw new Error(`requested RPC driver "${backendName}" is not installed`);
         }
-        this.driverObjects.set(backendName, newDriver);
-        return newDriver;
     }
     async getDriverForCall(_sessionId, _functionName, args) {
         const backendName = args.rpcDriverName ||

package/rpc/configSchema.js

@@ -28,7 +28,6 @@ exports.default = (0, configuration_1.ConfigurationSchema)('RpcOptions', {
         WebWorkerRpcDriver: { type: 'WebWorkerRpcDriver' },
     }),
 }, {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     actions: (self) => ({
         addDriverConfig(configName, configSnapshot) {
             self.drivers.set(configName, configSnapshot);

package/rpc/methods/CoreFreeResources.d.ts

@@ -7,6 +7,6 @@ import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
  */
 export default class CoreFreeResources extends RpcMethodType {
     name: string;
-    execute(specification: {}): Promise<number>;
-    serializeArguments(args: {}, _rpcDriver: string): Promise<{}>;
+    execute(specification: Record<string, unknown>): Promise<number>;
+    serializeArguments(args: Record<string, unknown>, _rpcDriver: string): Promise<Record<string, unknown>>;
 }

package/rpc/methods/CoreGetFeatureDensityStats.d.ts

@@ -7,9 +7,9 @@ export default class CoreGetFeatureDensityStats extends RpcMethodType {
     serializeArguments(args: RenderArgs & {
         signal?: AbortSignal;
         statusCallback?: (arg: string) => void;
-    }, rpcDriver: string): Promise<{}>;
+    }, rpcDriver: string): Promise<Record<string, unknown>>;
     execute(args: {
-        adapterConfig: {};
+        adapterConfig: Record<string, unknown>;
         regions: Region[];
         signal?: RemoteAbortSignal;
         headers?: Record<string, string>;

package/rpc/methods/CoreGetFeatureDetails.d.ts

@@ -7,7 +7,7 @@ import { RenderArgsSerialized } from './util';
  */
 export default class CoreGetFeatureDetails extends RpcMethodType {
     name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("../../pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized | RenderArgs>;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<any>;
     execute(args: RenderArgsSerialized & {
         signal?: RemoteAbortSignal;
     }, rpcDriver: string): Promise<{

package/rpc/methods/CoreGetFeatureDetails.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
 const util_1 = require("../../util");
-const util_2 = require("./util");
 /**
  * fetches features from an adapter and call a renderer with them
  */
@@ -23,7 +22,8 @@ class CoreGetFeatureDetails extends RpcMethodType_1.default {
             return superArgs;
         }
         const { rendererType } = args;
-        const RendererType = (0, util_2.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        const RendererType = this.pluginManager.getRendererType(rendererType);
+        // @ts-expect-error
         return RendererType.serializeArgsInClient(superArgs);
     }
     async execute(args, rpcDriver) {
@@ -33,7 +33,7 @@ class CoreGetFeatureDetails extends RpcMethodType_1.default {
             deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         }
         const { rendererType, featureId } = deserializedArgs;
-        const RendererType = (0, util_2.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        const RendererType = this.pluginManager.getRendererType(rendererType);
         return {
             // @ts-expect-error
             feature: (_b = (_a = RendererType.sessions[(0, util_1.getLayoutId)(args)]) === null || _a === void 0 ? void 0 : _a.cachedLayout.layout.getDataByID(featureId)) === null || _b === void 0 ? void 0 : _b.toJSON(),

package/rpc/methods/CoreGetFeatures.d.ts

@@ -10,7 +10,7 @@ export default class CoreGetFeatures extends RpcMethodType {
     execute(args: {
         sessionId: string;
         regions: Region[];
-        adapterConfig: {};
+        adapterConfig: Record<string, unknown>;
         signal?: RemoteAbortSignal;
         opts?: any;
     }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;

package/rpc/methods/CoreGetFileInfo.d.ts

@@ -5,6 +5,6 @@ export default class CoreGetFileInfo extends RpcMethodType {
     execute(args: {
         sessionId: string;
         signal: RemoteAbortSignal;
-        adapterConfig: {};
+        adapterConfig: Record<string, unknown>;
     }, rpcDriver: string): Promise<unknown>;
 }

package/rpc/methods/CoreGetMetadata.d.ts

@@ -5,6 +5,6 @@ export default class CoreGetMetadata extends RpcMethodType {
     execute(args: {
         sessionId: string;
         signal: RemoteAbortSignal;
-        adapterConfig: {};
+        adapterConfig: Record<string, unknown>;
     }, rpcDriver: string): Promise<unknown>;
 }

package/rpc/methods/CoreGetRefNames.d.ts

@@ -5,6 +5,6 @@ export default class CoreGetRefNames extends RpcMethodType {
     execute(args: {
         sessionId: string;
         signal: RemoteAbortSignal;
-        adapterConfig: {};
+        adapterConfig: Record<string, unknown>;
     }, rpcDriver: string): Promise<string[]>;
 }

package/rpc/methods/util.d.ts

@@ -2,13 +2,13 @@ import { ServerSideRendererType } from '../../pluggableElementTypes';
 import { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized } from '../../pluggableElementTypes/renderers/ServerSideRendererType';
 import { Region } from '../../util';
 export interface RenderArgs extends ServerSideRenderArgs {
-    adapterConfig: {};
+    adapterConfig: Record<string, unknown>;
     rendererType: string;
 }
 export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
     assemblyName: string;
     regions: Region[];
-    adapterConfig: {};
+    adapterConfig: Record<string, unknown>;
     rendererType: string;
 }
 export declare function validateRendererType<T>(rendererType: string, RendererType: T): ServerSideRendererType;

package/rpc/methods/util.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateRendererType = validateRendererType;
 function validateRendererType(rendererType, RendererType) {
-    if (!RendererType) {
-        throw new Error(`renderer "${rendererType}" not found`);
-    }
     // @ts-expect-error
     if (!RendererType.ReactComponent) {
         throw new Error(`renderer ${rendererType} has no ReactComponent, it may not be completely implemented yet`);