@jbrowse/core 2.2.2 → 2.3.0

package/rpc/methods/CoreFreeResources.d.ts

@@ -0,0 +1,12 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+/**
+ * free up any resources (e.g. cached adapter objects)
+ * that are only associated with the given track ID.
+ *
+ * returns number of objects deleted
+ */
+export default class CoreFreeResources extends RpcMethodType {
+    name: string;
+    execute(specification: {}): Promise<number>;
+    serializeArguments(args: {}, _rpcDriver: string): Promise<{}>;
+}

package/rpc/methods/CoreFreeResources.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("../../pluggableElementTypes/RpcMethodType"));
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+/**
+ * free up any resources (e.g. cached adapter objects)
+ * that are only associated with the given track ID.
+ *
+ * returns number of objects deleted
+ */
+class CoreFreeResources extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreFreeResources';
+    }
+    async execute(specification) {
+        let deleteCount = 0;
+        deleteCount += (0, dataAdapterCache_1.freeAdapterResources)(specification);
+        // pass the freeResources hint along to all the renderers as well
+        this.pluginManager.getRendererTypes().forEach(renderer => {
+            const count = renderer.freeResources( /* specification */);
+            if (count) {
+                deleteCount += count;
+            }
+        });
+        return deleteCount;
+    }
+    async serializeArguments(args, _rpcDriver) {
+        return args;
+    }
+}
+exports.default = CoreFreeResources;

package/rpc/methods/CoreGetFeatureDetails.d.ts

@@ -0,0 +1,16 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RenderArgs } from './util';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+import { RenderArgsSerialized } from './util';
+/**
+ * fetches features from an adapter and call a renderer with them
+ */
+export default class CoreGetFeatureDetails extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("../../pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized | RenderArgs>;
+    execute(args: RenderArgsSerialized & {
+        signal?: RemoteAbortSignal;
+    }, rpcDriver: string): Promise<{
+        feature: any;
+    }>;
+}

package/rpc/methods/CoreGetFeatureDetails.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+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 CoreGetFeatureDetails extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreGetFeatureDetails';
+    }
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, args);
+        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
+        if (rpcDriver === 'MainThreadRpcDriver') {
+            return superArgs;
+        }
+        const { rendererType } = args;
+        const RendererType = (0, util_2.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 { rendererType, featureId } = deserializedArgs;
+        const RendererType = (0, util_2.validateRendererType)(rendererType, this.pluginManager.getRendererType(rendererType));
+        // @ts-ignore
+        const sess = RendererType.sessions[(0, util_1.getLayoutId)(args)];
+        const { layout } = sess.cachedLayout;
+        const xref = layout.getDataByID(featureId);
+        return { feature: xref.toJSON() };
+    }
+}
+exports.default = CoreGetFeatureDetails;

package/rpc/methods/CoreGetFeatures.d.ts

@@ -0,0 +1,17 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RenderArgs } from './util';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+import { Region } from '../../util';
+import SimpleFeature, { SimpleFeatureSerialized } from '../../util/simpleFeature';
+export default class CoreGetFeatures extends RpcMethodType {
+    name: string;
+    deserializeReturn(feats: SimpleFeatureSerialized[], args: unknown, rpcDriver: string): Promise<SimpleFeature[]>;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
+    execute(args: {
+        sessionId: string;
+        regions: Region[];
+        adapterConfig: {};
+        signal?: RemoteAbortSignal;
+        opts?: any;
+    }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;
+}

package/rpc/methods/CoreGetFeatures.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const operators_1 = require("rxjs/operators");
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
+const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
+const util_1 = require("../../util");
+const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
+class CoreGetFeatures extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreGetFeatures';
+    }
+    async deserializeReturn(feats, args, rpcDriver) {
+        const superDeserialized = (await super.deserializeReturn(feats, args, rpcDriver));
+        return superDeserialized.map(feat => new simpleFeature_1.default(feat));
+    }
+    async serializeArguments(args, rpcDriver) {
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, args);
+        return super.serializeArguments(renamedArgs, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { signal, sessionId, adapterConfig, regions, opts } = deserializedArgs;
+        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
+        if (!(0, BaseAdapter_1.isFeatureAdapter)(dataAdapter)) {
+            throw new Error('Adapter does not support retrieving features');
+        }
+        const ret = dataAdapter.getFeaturesInMultipleRegions(regions, {
+            ...opts,
+            signal,
+        });
+        const r = await ret.pipe((0, operators_1.toArray)()).toPromise();
+        return r.map(f => f.toJSON());
+    }
+}
+exports.default = CoreGetFeatures;

package/rpc/methods/CoreGetFileInfo.d.ts

@@ -0,0 +1,10 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+export default class CoreGetFileInfo extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        signal: RemoteAbortSignal;
+        adapterConfig: {};
+    }, rpcDriver: string): Promise<unknown>;
+}

package/rpc/methods/CoreGetFileInfo.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
+const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
+class CoreGetFileInfo extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreGetInfo';
+    }
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
+        return (0, BaseAdapter_1.isFeatureAdapter)(dataAdapter)
+            ? dataAdapter.getHeader(deserializedArgs)
+            : null;
+    }
+}
+exports.default = CoreGetFileInfo;

package/rpc/methods/CoreGetMetadata.d.ts

@@ -0,0 +1,10 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+export default class CoreGetMetadata extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        signal: RemoteAbortSignal;
+        adapterConfig: {};
+    }, rpcDriver: string): Promise<unknown>;
+}

package/rpc/methods/CoreGetMetadata.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
+const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
+class CoreGetMetadata extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreGetMetadata';
+    }
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
+        return (0, BaseAdapter_1.isFeatureAdapter)(dataAdapter)
+            ? dataAdapter.getMetadata(deserializedArgs)
+            : null;
+    }
+}
+exports.default = CoreGetMetadata;

package/rpc/methods/CoreGetRefNames.d.ts

@@ -0,0 +1,10 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+export default class CoreGetRefNames extends RpcMethodType {
+    name: string;
+    execute(args: {
+        sessionId: string;
+        signal: RemoteAbortSignal;
+        adapterConfig: {};
+    }, rpcDriver: string): Promise<string[]>;
+}

package/rpc/methods/CoreGetRefNames.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
+const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
+class CoreGetRefNames extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreGetRefNames';
+    }
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { sessionId, adapterConfig } = deserializedArgs;
+        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
+        if ((0, BaseAdapter_1.isFeatureAdapter)(dataAdapter)) {
+            return dataAdapter.getRefNames(deserializedArgs);
+        }
+        return [];
+    }
+}
+exports.default = CoreGetRefNames;

package/rpc/methods/CoreRender.d.ts

@@ -0,0 +1,14 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RenderResults, ResultsSerialized, RenderArgs, RenderArgsSerialized } from './util';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+/**
+ * fetches features from an adapter and call a renderer with them
+ */
+export default class CoreRender extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("../../pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized | RenderArgs>;
+    execute(args: RenderArgsSerialized & {
+        signal?: RemoteAbortSignal;
+    }, rpcDriver: string): Promise<ResultsSerialized | RenderResults>;
+    deserializeReturn(serializedReturn: RenderResults | ResultsSerialized, args: RenderArgs, rpcDriver: string): Promise<unknown>;
+}

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)