@jbrowse/core 3.7.0 → 4.0.0

package/rpc/BaseRpcDriver.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("../configuration");
-const util_1 = require("../util");
-function isCloneable(thing) {
-    return !(typeof thing === 'function') && !(thing instanceof Error);
-}
-function detectHardwareConcurrency() {
-    const mainThread = typeof window !== 'undefined';
-    const canDetect = mainThread && 'hardwareConcurrency' in window.navigator;
-    return mainThread && canDetect ? window.navigator.hardwareConcurrency : 1;
-}
-class LazyWorker {
-    constructor(driver) {
-        this.driver = driver;
-    }
-    async getWorker() {
-        if (!this.workerP) {
-            this.workerP = this.driver.makeWorker().catch((e) => {
-                this.workerP = undefined;
-                throw e;
-            });
-        }
-        return this.workerP;
-    }
-}
-class BaseRpcDriver {
-    constructor(args) {
-        this.lastWorkerAssignment = -1;
-        this.workerAssignments = new Map();
-        this.maxPingTime = 30000;
-        this.workerCheckFrequency = 5000;
-        this.config = args.config;
-    }
-    filterArgs(thing, sessionId) {
-        if (Array.isArray(thing)) {
-            return thing
-                .filter(thing => isCloneable(thing))
-                .map(t => this.filterArgs(t, sessionId));
-        }
-        else if (typeof thing === 'object' && thing !== null) {
-            if ((0, mobx_state_tree_1.isStateTreeNode)(thing) && !(0, mobx_state_tree_1.isAlive)(thing)) {
-                throw new Error('dead state tree node passed to RPC call');
-            }
-            else if (thing instanceof File) {
-                return thing;
-            }
-            else {
-                return Object.fromEntries(Object.entries(thing)
-                    .filter(e => isCloneable(e[1]))
-                    .map(([k, v]) => [k, this.filterArgs(v, sessionId)]));
-            }
-        }
-        else {
-            return thing;
-        }
-    }
-    async remoteAbort(sessionId, functionName, stopTokenId) {
-        const worker = await this.getWorker(sessionId);
-        await worker.call(functionName, { stopTokenId }, { timeout: 1000000, rpcDriverClassName: this.name });
-    }
-    createWorkerPool() {
-        const hardwareConcurrency = detectHardwareConcurrency();
-        const workerCount = (0, configuration_1.readConfObject)(this.config, 'workerCount') ||
-            (0, util_1.clamp)(1, Math.max(1, hardwareConcurrency - 1), 5);
-        const workers = [];
-        for (let i = 0; i < workerCount; i++) {
-            workers.push(new LazyWorker(this));
-        }
-        return workers;
-    }
-    getWorkerPool() {
-        if (!this.workerPool) {
-            const res = this.createWorkerPool();
-            this.workerPool = res;
-            return res;
-        }
-        return this.workerPool;
-    }
-    async getWorker(sessionId) {
-        const workers = this.getWorkerPool();
-        let workerNumber = this.workerAssignments.get(sessionId);
-        if (workerNumber === undefined) {
-            const workerAssignment = (this.lastWorkerAssignment + 1) % workers.length;
-            this.workerAssignments.set(sessionId, workerAssignment);
-            this.lastWorkerAssignment = workerAssignment;
-            workerNumber = workerAssignment;
-        }
-        return workers[workerNumber].getWorker();
-    }
-    async call(pluginManager, sessionId, functionName, args, options = {}) {
-        if (!sessionId) {
-            throw new TypeError('sessionId is required');
-        }
-        const unextendedWorker = await this.getWorker(sessionId);
-        const worker = pluginManager.evaluateExtensionPoint('Core-extendWorker', unextendedWorker);
-        const rpcMethod = pluginManager.getRpcMethodType(functionName);
-        if (!rpcMethod) {
-            throw new Error(`unknown RPC method ${functionName}`);
-        }
-        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
-        const filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId);
-        const call = await worker.call(functionName, filteredAndSerializedArgs, {
-            timeout: 5 * 60 * 1000,
-            statusCallback: args.statusCallback,
-            rpcDriverClassName: this.name,
-            ...options,
-        });
-        return rpcMethod.deserializeReturn(call, args, this.name);
-    }
-}
-exports.default = BaseRpcDriver;

package/rpc/MainThreadRpcDriver.d.ts

@@ -1,14 +0,0 @@
-import BaseRpcDriver from './BaseRpcDriver';
-import type { RpcDriverConstructorArgs } from './BaseRpcDriver';
-import type PluginManager from '../PluginManager';
-declare class DummyHandle {
-    destroy(): void;
-    call(_functionName: string, _filteredArgs?: Record<string, unknown>, _options?: {}): Promise<unknown>;
-}
-export default class MainThreadRpcDriver extends BaseRpcDriver {
-    name: string;
-    makeWorker: () => Promise<DummyHandle>;
-    constructor(args: RpcDriverConstructorArgs);
-    call(pm: PluginManager, sessionId: string, funcName: string, args: Record<string, unknown>): Promise<unknown>;
-}
-export {};

package/rpc/MainThreadRpcDriver.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseRpcDriver_1 = __importDefault(require("./BaseRpcDriver"));
-class DummyHandle {
-    destroy() { }
-    async call(_functionName, _filteredArgs, _options = {}) {
-        return undefined;
-    }
-}
-class MainThreadRpcDriver extends BaseRpcDriver_1.default {
-    constructor(args) {
-        super(args);
-        this.name = 'MainThreadRpcDriver';
-        this.makeWorker = async () => new DummyHandle();
-    }
-    async call(pm, sessionId, funcName, args) {
-        if (!sessionId) {
-            throw new TypeError('sessionId is required');
-        }
-        const rpcMethod = pm.getRpcMethodType(funcName);
-        if (!rpcMethod) {
-            throw new Error(`unknown RPC method ${funcName}`);
-        }
-        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
-        const result = await rpcMethod.execute(serializedArgs, this.name);
-        return rpcMethod.deserializeReturn(result, args, this.name);
-    }
-}
-exports.default = MainThreadRpcDriver;

package/rpc/RpcManager.d.ts

@@ -1,34 +0,0 @@
-import MainThreadRpcDriver from './MainThreadRpcDriver';
-import WebWorkerRpcDriver from './WebWorkerRpcDriver';
-import type PluginManager from '../PluginManager';
-import type { AnyConfigurationModel } from '../configuration';
-type DriverClass = WebWorkerRpcDriver | MainThreadRpcDriver;
-interface BackendConfigurations {
-    WebWorkerRpcDriver?: Omit<ConstructorParameters<typeof WebWorkerRpcDriver>[0], 'config'>;
-    MainThreadRpcDriver?: Omit<ConstructorParameters<typeof MainThreadRpcDriver>[0], 'config'>;
-}
-declare const DriverClasses: {
-    WebWorkerRpcDriver: typeof WebWorkerRpcDriver;
-    MainThreadRpcDriver: typeof MainThreadRpcDriver;
-};
-export default class RpcManager {
-    pluginManager: PluginManager;
-    mainConfiguration: AnyConfigurationModel;
-    backendConfigurations: BackendConfigurations;
-    static configSchema: import("../configuration/configurationSchema").ConfigurationSchemaType<{
-        defaultDriver: {
-            type: string;
-            description: string;
-            defaultValue: string;
-        };
-        drivers: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IMapType<import("mobx-state-tree").ITypeUnion<import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> | undefined, import("mobx-state-tree").ModelSnapshotType<Record<string, any>>, ({} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> & import("mobx-state-tree/dist/internal").NonEmptyObject) | undefined>>, [undefined]>;
-    }, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-    driverObjects: Map<string, DriverClass>;
-    constructor(pluginManager: PluginManager, mainConfiguration: AnyConfigurationModel, backendConfigurations: BackendConfigurations);
-    getDriver(backendName: keyof typeof DriverClasses): DriverClass;
-    getDriverForCall(_sessionId: string, _functionName: string, args: {
-        rpcDriverName?: string;
-    }): Promise<DriverClass>;
-    call(sessionId: string, functionName: string, args: Record<string, unknown>, opts?: {}): Promise<unknown>;
-}
-export {};

package/rpc/RpcManager.js

@@ -1,69 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const configuration_1 = require("../configuration");
-const MainThreadRpcDriver_1 = __importDefault(require("./MainThreadRpcDriver"));
-const WebWorkerRpcDriver_1 = __importDefault(require("./WebWorkerRpcDriver"));
-const configSchema_1 = __importDefault(require("./configSchema"));
-const DriverClasses = {
-    WebWorkerRpcDriver: WebWorkerRpcDriver_1.default,
-    MainThreadRpcDriver: MainThreadRpcDriver_1.default,
-};
-class RpcManager {
-    constructor(pluginManager, mainConfiguration, backendConfigurations) {
-        this.pluginManager = pluginManager;
-        this.mainConfiguration = mainConfiguration;
-        this.backendConfigurations = backendConfigurations;
-        this.driverObjects = new Map();
-    }
-    getDriver(backendName) {
-        const driver = this.driverObjects.get(backendName);
-        if (driver) {
-            return driver;
-        }
-        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`);
-            }
-            const newDriver = new MainThreadRpcDriver_1.default({
-                ...backendConfiguration,
-                config,
-            });
-            this.driverObjects.set(backendName, newDriver);
-            return newDriver;
-        }
-        else if (backendName === 'WebWorkerRpcDriver') {
-            const backendConfiguration = this.backendConfigurations.WebWorkerRpcDriver;
-            if (!backendConfiguration) {
-                throw new Error(`requested RPC driver "${backendName}" is missing 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`);
-        }
-    }
-    async getDriverForCall(_sessionId, _functionName, args) {
-        const backendName = args.rpcDriverName ||
-            (0, configuration_1.readConfObject)(this.mainConfiguration, 'defaultDriver');
-        return this.getDriver(backendName);
-    }
-    async call(sessionId, functionName, args, opts = {}) {
-        if (!sessionId) {
-            throw new Error('sessionId is required');
-        }
-        const driverForCall = await this.getDriverForCall(sessionId, functionName, args);
-        return driverForCall.call(this.pluginManager, sessionId, functionName, args, opts);
-    }
-}
-RpcManager.configSchema = configSchema_1.default;
-exports.default = RpcManager;

package/rpc/WebWorkerRpcDriver.d.ts

@@ -1,29 +0,0 @@
-import Rpc from 'librpc-web-mod';
-import BaseRpcDriver from './BaseRpcDriver';
-import type { RpcDriverConstructorArgs } from './BaseRpcDriver';
-import type { PluginDefinition } from '../PluginLoader';
-interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
-    makeWorkerInstance: () => Worker;
-}
-interface Options {
-    statusCallback?: (arg0: unknown) => void;
-    rpcDriverClassName: string;
-}
-declare class WebWorkerHandle extends Rpc.Client {
-    destroy(): void;
-    call(funcName: string, args: Record<string, unknown>, opts: Options): Promise<unknown>;
-}
-export default class WebWorkerRpcDriver extends BaseRpcDriver {
-    workerBootConfiguration: {
-        plugins: PluginDefinition[];
-        windowHref: string;
-    };
-    name: string;
-    makeWorkerInstance: () => Worker;
-    constructor(args: WebWorkerRpcDriverConstructorArgs, workerBootConfiguration: {
-        plugins: PluginDefinition[];
-        windowHref: string;
-    });
-    makeWorker(): Promise<WebWorkerHandle>;
-}
-export {};

package/rpc/WebWorkerRpcDriver.js

@@ -1,65 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const librpc_web_mod_1 = __importDefault(require("librpc-web-mod"));
-const serialize_error_1 = require("serialize-error");
-const BaseRpcDriver_1 = __importDefault(require("./BaseRpcDriver"));
-const nanoid_1 = require("../util/nanoid");
-class WebWorkerHandle extends librpc_web_mod_1.default.Client {
-    destroy() {
-        this.workers[0].terminate();
-    }
-    async call(funcName, args, opts) {
-        const { statusCallback, rpcDriverClassName } = opts;
-        const channel = `message-${(0, nanoid_1.nanoid)()}`;
-        const listener = (message) => {
-            statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(message);
-        };
-        this.on(channel, listener);
-        const result = await super.call(funcName, { ...args, channel, rpcDriverClassName }, opts);
-        this.off(channel, listener);
-        return result;
-    }
-}
-class WebWorkerRpcDriver extends BaseRpcDriver_1.default {
-    constructor(args, workerBootConfiguration) {
-        super(args);
-        this.workerBootConfiguration = workerBootConfiguration;
-        this.name = 'WebWorkerRpcDriver';
-        this.makeWorkerInstance = args.makeWorkerInstance;
-    }
-    async makeWorker() {
-        const instance = this.makeWorkerInstance();
-        const worker = new WebWorkerHandle({ workers: [instance] });
-        const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-        if (isSafari) {
-            console.log('console logging the webworker handle avoids the track going into an infinite loading state, this is a hacky workaround for safari', instance);
-        }
-        return new Promise((resolve, reject) => {
-            const listener = (e) => {
-                switch (e.data.message) {
-                    case 'ready': {
-                        resolve(worker);
-                        worker.workers[0].removeEventListener('message', listener);
-                        break;
-                    }
-                    case 'readyForConfig': {
-                        worker.workers[0].postMessage({
-                            message: 'config',
-                            config: this.workerBootConfiguration,
-                        });
-                        break;
-                    }
-                    case 'error': {
-                        reject((0, serialize_error_1.deserializeError)(e.data.error));
-                        break;
-                    }
-                }
-            };
-            worker.workers[0].addEventListener('message', listener);
-        });
-    }
-}
-exports.default = WebWorkerRpcDriver;

package/rpc/baseRpcConfig.d.ts

@@ -1,8 +0,0 @@
-declare const BaseRpcDriverConfigSchema: import("../configuration/configurationSchema").ConfigurationSchemaType<{
-    workerCount: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-}, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-export default BaseRpcDriverConfigSchema;

package/rpc/baseRpcConfig.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const configuration_1 = require("../configuration");
-function x() { }
-const BaseRpcDriverConfigSchema = (0, configuration_1.ConfigurationSchema)('BaseRpcDriver', {
-    workerCount: {
-        type: 'number',
-        description: 'The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.',
-        defaultValue: 0,
-    },
-}, { explicitlyTyped: true });
-exports.default = BaseRpcDriverConfigSchema;

package/rpc/configSchema.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("../configuration/configurationSchema").ConfigurationSchemaType<{
-    defaultDriver: {
-        type: string;
-        description: string;
-        defaultValue: string;
-    };
-    drivers: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IMapType<import("mobx-state-tree").ITypeUnion<import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> | undefined, import("mobx-state-tree").ModelSnapshotType<Record<string, any>>, ({} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> & import("mobx-state-tree/dist/internal").NonEmptyObject) | undefined>>, [undefined]>;
-}, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-export default _default;

package/rpc/configSchema.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mobx_state_tree_1 = require("mobx-state-tree");
-const configuration_1 = require("../configuration");
-const mainThreadRpcConfig_1 = __importDefault(require("./mainThreadRpcConfig"));
-const webWorkerRpcConfig_1 = __importDefault(require("./webWorkerRpcConfig"));
-function x() { }
-exports.default = (0, configuration_1.ConfigurationSchema)('RpcOptions', {
-    defaultDriver: {
-        type: 'string',
-        description: 'the RPC driver to use for tracks and tasks that are not configured to use a specific RPC backend',
-        defaultValue: 'MainThreadRpcDriver',
-    },
-    drivers: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.map(mobx_state_tree_1.types.union(mainThreadRpcConfig_1.default, webWorkerRpcConfig_1.default)), {
-        MainThreadRpcDriver: { type: 'MainThreadRpcDriver' },
-        WebWorkerRpcDriver: { type: 'WebWorkerRpcDriver' },
-    }),
-}, {
-    actions: (self) => ({
-        addDriverConfig(configName, configSnapshot) {
-            self.drivers.set(configName, configSnapshot);
-        },
-    }),
-});

package/rpc/coreRpcMethods.d.ts

@@ -1,9 +0,0 @@
-export { default as CoreGetRefNames } from './methods/CoreGetRefNames';
-export { default as CoreGetFeatureDetails } from './methods/CoreGetFeatureDetails';
-export { default as CoreGetMetadata } from './methods/CoreGetMetadata';
-export { default as CoreGetFileInfo } from './methods/CoreGetFileInfo';
-export { default as CoreGetFeatures } from './methods/CoreGetFeatures';
-export { default as CoreRender } from './methods/CoreRender';
-export { default as CoreFreeResources } from './methods/CoreFreeResources';
-export { default as CoreGetFeatureDensityStats } from './methods/CoreGetFeatureDensityStats';
-export { type RenderArgs } from './methods/util';

package/rpc/coreRpcMethods.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreGetFeatureDensityStats = exports.CoreFreeResources = exports.CoreRender = exports.CoreGetFeatures = exports.CoreGetFileInfo = exports.CoreGetMetadata = exports.CoreGetFeatureDetails = exports.CoreGetRefNames = void 0;
-var CoreGetRefNames_1 = require("./methods/CoreGetRefNames");
-Object.defineProperty(exports, "CoreGetRefNames", { enumerable: true, get: function () { return __importDefault(CoreGetRefNames_1).default; } });
-var CoreGetFeatureDetails_1 = require("./methods/CoreGetFeatureDetails");
-Object.defineProperty(exports, "CoreGetFeatureDetails", { enumerable: true, get: function () { return __importDefault(CoreGetFeatureDetails_1).default; } });
-var CoreGetMetadata_1 = require("./methods/CoreGetMetadata");
-Object.defineProperty(exports, "CoreGetMetadata", { enumerable: true, get: function () { return __importDefault(CoreGetMetadata_1).default; } });
-var CoreGetFileInfo_1 = require("./methods/CoreGetFileInfo");
-Object.defineProperty(exports, "CoreGetFileInfo", { enumerable: true, get: function () { return __importDefault(CoreGetFileInfo_1).default; } });
-var CoreGetFeatures_1 = require("./methods/CoreGetFeatures");
-Object.defineProperty(exports, "CoreGetFeatures", { enumerable: true, get: function () { return __importDefault(CoreGetFeatures_1).default; } });
-var CoreRender_1 = require("./methods/CoreRender");
-Object.defineProperty(exports, "CoreRender", { enumerable: true, get: function () { return __importDefault(CoreRender_1).default; } });
-var CoreFreeResources_1 = require("./methods/CoreFreeResources");
-Object.defineProperty(exports, "CoreFreeResources", { enumerable: true, get: function () { return __importDefault(CoreFreeResources_1).default; } });
-var CoreGetFeatureDensityStats_1 = require("./methods/CoreGetFeatureDensityStats");
-Object.defineProperty(exports, "CoreGetFeatureDensityStats", { enumerable: true, get: function () { return __importDefault(CoreGetFeatureDensityStats_1).default; } });

package/rpc/mainThreadRpcConfig.d.ts

@@ -1,8 +0,0 @@
-declare const MainThreadRpcDriverConfigSchema: import("../configuration/configurationSchema").ConfigurationSchemaType<{}, import("../configuration/configurationSchema").ConfigurationSchemaOptions<import("../configuration/configurationSchema").ConfigurationSchemaType<{
-    workerCount: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-}, import("../configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>, undefined>>;
-export default MainThreadRpcDriverConfigSchema;

package/rpc/mainThreadRpcConfig.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const configuration_1 = require("../configuration");
-const baseRpcConfig_1 = __importDefault(require("./baseRpcConfig"));
-function x() { }
-const MainThreadRpcDriverConfigSchema = (0, configuration_1.ConfigurationSchema)('MainThreadRpcDriver', {}, {
-    baseConfiguration: baseRpcConfig_1.default,
-    explicitlyTyped: true,
-});
-exports.default = MainThreadRpcDriverConfigSchema;

package/rpc/methods/CoreFreeResources.d.ts

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

package/rpc/methods/CoreFreeResources.js

@@ -1,23 +0,0 @@
-"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"));
-class CoreFreeResources extends RpcMethodType_1.default {
-    constructor() {
-        super(...arguments);
-        this.name = 'CoreFreeResources';
-    }
-    async execute(args) {
-        await (0, dataAdapterCache_1.freeAdapterResources)(args);
-        for (const renderer of this.pluginManager.getRendererTypes()) {
-            renderer.freeResources(args);
-        }
-    }
-    async serializeArguments(args, _rpcDriver) {
-        return args;
-    }
-}
-exports.default = CoreFreeResources;

package/rpc/methods/CoreGetFeatureDensityStats.d.ts

@@ -1,17 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
-import type { RenderArgs } from './util';
-import type { Region } from '../../util';
-export default class CoreGetFeatureDensityStats extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs & {
-        stopToken?: string;
-        statusCallback?: (arg: string) => void;
-    }, rpcDriver: string): Promise<Record<string, unknown>>;
-    execute(args: {
-        adapterConfig: Record<string, unknown>;
-        regions: Region[];
-        stopToken?: string;
-        headers?: Record<string, string>;
-        sessionId: string;
-    }, rpcDriver: string): Promise<import("../../data_adapters/BaseAdapter").FeatureDensityStats>;
-}

package/rpc/methods/CoreGetFeatureDensityStats.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
-const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
-const RpcMethodType_1 = __importDefault(require("../../pluggableElementTypes/RpcMethodType"));
-const util_1 = require("../../util");
-class CoreGetFeatureDensityStats extends RpcMethodType_1.default {
-    constructor() {
-        super(...arguments);
-        this.name = 'CoreGetFeatureDensityStats';
-    }
-    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.getMultiRegionFeatureDensityStats(regions, deserializedArgs);
-    }
-}
-exports.default = CoreGetFeatureDensityStats;

package/rpc/methods/CoreGetFeatureDetails.d.ts

@@ -1,11 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
-import type { RenderArgs, RenderArgsSerialized } from './util';
-export default class CoreGetFeatureDetails extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<any>;
-    execute(args: RenderArgsSerialized & {
-        stopToken?: string;
-    }, rpcDriver: string): Promise<{
-        feature: any;
-    }>;
-}

package/rpc/methods/CoreGetFeatureDetails.js

@@ -1,38 +0,0 @@
-"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 util_1 = require("../../util");
-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 = this.pluginManager.getRendererType(rendererType);
-        return RendererType.serializeArgsInClient(superArgs);
-    }
-    async execute(args, rpcDriver) {
-        var _a, _b;
-        let deserializedArgs = args;
-        if (rpcDriver !== 'MainThreadRpcDriver') {
-            deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        }
-        const { rendererType, featureId } = deserializedArgs;
-        const RendererType = this.pluginManager.getRendererType(rendererType);
-        return {
-            feature: (_b = (_a = RendererType.getLayoutSession(args)) === null || _a === void 0 ? void 0 : _a.cachedLayout.layout.getDataByID(featureId)) === null || _b === void 0 ? void 0 : _b.toJSON(),
-        };
-    }
-}
-exports.default = CoreGetFeatureDetails;

package/rpc/methods/CoreGetFeatures.d.ts

@@ -1,18 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType';
-import SimpleFeature from '../../util/simpleFeature';
-import type { RenderArgs } from './util';
-import type { Region } from '../../util';
-import type { 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: Record<string, unknown>;
-        statusCallback: (arg: string) => void;
-        stopToken?: string;
-        opts?: any;
-    }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;
-}