@jbrowse/core 2.2.1 → 2.3.0

package/rpc/methods/CoreRender.js

@@ -0,0 +1,57 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+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("../../pluggableElementTypes/RpcMethodType"));
+const util_1 = require("./util");
+const util_2 = require("../../util");
+/**
+ * fetches features from an adapter and call a renderer with them
+ */
+class CoreRender extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreRender';
+    }
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await (0, util_2.renameRegionsIfNeeded)(assemblyManager, args);
+        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
+        if (rpcDriver === 'MainThreadRpcDriver') {
+            return superArgs;
+        }
+        const { rendererType } = args;
+        const RendererType = (0, util_1.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        return RendererType.serializeArgsInClient(superArgs);
+    }
+    async execute(args, rpcDriver) {
+        let deserializedArgs = args;
+        if (rpcDriver !== 'MainThreadRpcDriver') {
+            deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        }
+        const { sessionId, rendererType, signal } = deserializedArgs;
+        if (!sessionId) {
+            throw new Error('must pass a unique session id');
+        }
+        (0, util_2.checkAbortSignal)(signal);
+        const RendererType = (0, util_1.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        const result = rpcDriver === 'MainThreadRpcDriver'
+            ? await RendererType.render(deserializedArgs)
+            : await RendererType.renderInWorker(deserializedArgs);
+        (0, util_2.checkAbortSignal)(signal);
+        return result;
+    }
+    async deserializeReturn(serializedReturn, args, rpcDriver) {
+        const des = await super.deserializeReturn(serializedReturn, args, rpcDriver);
+        if (rpcDriver === 'MainThreadRpcDriver') {
+            return des;
+        }
+        const { rendererType } = args;
+        const RendererType = (0, util_1.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        return RendererType.deserializeResultsInClient(des, args);
+    }
+}
+exports.default = CoreRender;

package/rpc/methods/util.d.ts

@@ -0,0 +1,14 @@
+import ServerSideRendererType, { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults, ResultsSerialized } from '../../pluggableElementTypes/renderers/ServerSideRendererType';
+import { Region } from '../../util';
+export interface RenderArgs extends ServerSideRenderArgs {
+    adapterConfig: {};
+    rendererType: string;
+}
+export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
+    assemblyName: string;
+    regions: Region[];
+    adapterConfig: {};
+    rendererType: string;
+}
+export type { RenderResults, ResultsSerialized };
+export declare function validateRendererType<T>(rendererType: string, RendererType: T): T & ServerSideRendererType;

package/rpc/methods/util.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRendererType = void 0;
+const ServerSideRendererType_1 = __importDefault(require("../../pluggableElementTypes/renderers/ServerSideRendererType"));
+function validateRendererType(rendererType, RendererType) {
+    if (!RendererType) {
+        throw new Error(`renderer "${rendererType}" not found`);
+    }
+    // @ts-ignore
+    if (!RendererType.ReactComponent) {
+        throw new Error(`renderer ${rendererType} has no ReactComponent, it may not be completely implemented yet`);
+    }
+    if (!(RendererType instanceof ServerSideRendererType_1.default)) {
+        throw new Error('CoreRender requires a renderer that is a subclass of ServerSideRendererType');
+    }
+    return RendererType;
+}
+exports.validateRendererType = validateRendererType;

package/rpc/remoteAbortSignals.d.ts

@@ -2,7 +2,9 @@ export type RemoteAbortSignal = {
     abortSignalId: number;
 };
 /**
- * assign an ID to the given abort signal and return a plain object representation
+ * assign an ID to the given abort signal and return a plain object
+ * representation
+ *
  * @param signal - the signal to serialize
  * @param callfunc - function used to call
  *  a remote method, will be called like callfunc('signalAbort', signalId)

package/rpc/remoteAbortSignals.js

@@ -5,7 +5,9 @@ exports.remoteAbortRpcHandler = exports.remoteAbort = exports.deserializeAbortSi
 let abortSignalCounter = 0;
 const abortSignalIds = new WeakMap(); // map of abortsignal => numerical ID
 /**
- * assign an ID to the given abort signal and return a plain object representation
+ * assign an ID to the given abort signal and return a plain object
+ * representation
+ *
  * @param signal - the signal to serialize
  * @param callfunc - function used to call
  *  a remote method, will be called like callfunc('signalAbort', signalId)