@jbrowse/core 2.2.1 → 2.3.0

package/rpc/coreRpcMethods.js

@@ -3,244 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreGetFeatureDetails = exports.CoreRender = exports.CoreEstimateRegionStats = exports.CoreFreeResources = exports.CoreGetFeatures = exports.CoreGetMetadata = exports.CoreGetFileInfo = exports.CoreGetRefNames = void 0;
-/* 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 ServerSideRendererType_1 = __importDefault(require("../pluggableElementTypes/renderers/ServerSideRendererType"));
-const BaseAdapter_1 = require("../data_adapters/BaseAdapter");
-const util_1 = require("../util");
-const simpleFeature_1 = __importDefault(require("../util/simpleFeature"));
-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.CoreGetRefNames = CoreGetRefNames;
-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.CoreGetFileInfo = CoreGetFileInfo;
-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.CoreGetMetadata = CoreGetMetadata;
-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.CoreGetFeatures = CoreGetFeatures;
-/**
- * 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.CoreFreeResources = CoreFreeResources;
-class CoreEstimateRegionStats extends RpcMethodType_1.default {
-    constructor() {
-        super(...arguments);
-        this.name = 'CoreEstimateRegionStats';
-    }
-    async serializeArguments(args, rpcDriver) {
-        var _a;
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, {
-            ...args,
-            filters: (_a = args.filters) === null || _a === void 0 ? void 0 : _a.toJSON().filters,
-        });
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { adapterConfig, sessionId, regions } = 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');
-        }
-        return dataAdapter.estimateRegionsStats(regions, deserializedArgs);
-    }
-}
-exports.CoreEstimateRegionStats = CoreEstimateRegionStats;
-/**
- * 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_1.renameRegionsIfNeeded)(assemblyManager, args);
-        const superArgs = (await super.serializeArguments(renamedArgs, rpcDriver));
-        if (rpcDriver === 'MainThreadRpcDriver') {
-            return superArgs;
-        }
-        const { rendererType } = args;
-        const RendererType = 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_1.checkAbortSignal)(signal);
-        const RendererType = validateRendererType(rendererType, this.pluginManager.getRendererType(rendererType));
-        const result = rpcDriver === 'MainThreadRpcDriver'
-            ? await RendererType.render(deserializedArgs)
-            : await RendererType.renderInWorker(deserializedArgs);
-        (0, util_1.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 = validateRendererType(rendererType, this.pluginManager.getRendererType(rendererType));
-        return RendererType.deserializeResultsInClient(des, args);
-    }
-}
-exports.CoreRender = CoreRender;
-/**
- * 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 = 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 = 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.CoreGetFeatureDetails = CoreGetFeatureDetails;
-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.CoreEstimateRegionStats = exports.CoreFreeResources = exports.CoreGetFeatureDetails = exports.CoreRender = exports.CoreGetFeatures = exports.CoreGetMetadata = exports.CoreGetFileInfo = exports.CoreGetRefNames = void 0;
+const CoreGetRefNames_1 = __importDefault(require("./methods/CoreGetRefNames"));
+exports.CoreGetRefNames = CoreGetRefNames_1.default;
+const CoreGetMetadata_1 = __importDefault(require("./methods/CoreGetMetadata"));
+exports.CoreGetMetadata = CoreGetMetadata_1.default;
+const CoreGetFeatureDetails_1 = __importDefault(require("./methods/CoreGetFeatureDetails"));
+exports.CoreGetFeatureDetails = CoreGetFeatureDetails_1.default;
+const CoreGetFeatures_1 = __importDefault(require("./methods/CoreGetFeatures"));
+exports.CoreGetFeatures = CoreGetFeatures_1.default;
+const CoreGetFileInfo_1 = __importDefault(require("./methods/CoreGetFileInfo"));
+exports.CoreGetFileInfo = CoreGetFileInfo_1.default;
+const CoreFreeResources_1 = __importDefault(require("./methods/CoreFreeResources"));
+exports.CoreFreeResources = CoreFreeResources_1.default;
+const CoreRender_1 = __importDefault(require("./methods/CoreRender"));
+exports.CoreRender = CoreRender_1.default;
+const CoreEstimateRegionStats_1 = __importDefault(require("./methods/CoreEstimateRegionStats"));
+exports.CoreEstimateRegionStats = CoreEstimateRegionStats_1.default;

package/rpc/methods/CoreEstimateRegionStats.d.ts

@@ -0,0 +1,18 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
+import { RenderArgs } from './util';
+import { RemoteAbortSignal } from '../remoteAbortSignals';
+import { Region } from '../../util';
+export default class CoreEstimateRegionStats extends RpcMethodType {
+    name: string;
+    serializeArguments(args: RenderArgs & {
+        signal?: AbortSignal;
+        statusCallback?: (arg: string) => void;
+    }, rpcDriver: string): Promise<{}>;
+    execute(args: {
+        adapterConfig: {};
+        regions: Region[];
+        signal?: RemoteAbortSignal;
+        headers?: Record<string, string>;
+        sessionId: string;
+    }, rpcDriver: string): Promise<import("../../data_adapters/BaseAdapter").Stats>;
+}

package/rpc/methods/CoreEstimateRegionStats.js

@@ -0,0 +1,37 @@
+"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 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");
+class CoreEstimateRegionStats extends RpcMethodType_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'CoreEstimateRegionStats';
+    }
+    async serializeArguments(args, rpcDriver) {
+        var _a;
+        const { rootModel } = this.pluginManager;
+        const assemblyManager = rootModel.session.assemblyManager;
+        const renamedArgs = await (0, util_1.renameRegionsIfNeeded)(assemblyManager, {
+            ...args,
+            filters: (_a = args.filters) === null || _a === void 0 ? void 0 : _a.toJSON().filters,
+        });
+        return super.serializeArguments(renamedArgs, rpcDriver);
+    }
+    async execute(args, rpcDriver) {
+        const pm = this.pluginManager;
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
+        const { adapterConfig, sessionId, regions } = 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');
+        }
+        return dataAdapter.estimateRegionsStats(regions, deserializedArgs);
+    }
+}
+exports.default = CoreEstimateRegionStats;

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>;
+}