@jbrowse/core 2.1.7 → 2.2.1

package/pluggableElementTypes/models/InternetAccountModel.js

@@ -6,37 +6,67 @@ const configuration_1 = require("../../configuration");
 const io_1 = require("../../util/io");
 const mst_1 = require("../../util/types/mst");
 const inWebWorker = typeof sessionStorage === 'undefined';
+/**
+ * #stateModel BaseInternetAccountModel
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.InternetAccount = mobx_state_tree_1.types
     .model('InternetAccount', {
+    /**
+     * #property
+     */
     id: mst_1.ElementId,
+    /**
+     * #property
+     */
     type: mobx_state_tree_1.types.string,
 })
     .views(self => ({
+    /**
+     * #getter
+     */
     get name() {
         return (0, configuration_1.getConf)(self, 'name');
     },
+    /**
+     * #getter
+     */
     get description() {
         return (0, configuration_1.getConf)(self, 'description');
     },
+    /**
+     * #getter
+     */
     get internetAccountId() {
         return (0, configuration_1.getConf)(self, 'internetAccountId');
     },
+    /**
+     * #getter
+     */
     get authHeader() {
         return (0, configuration_1.getConf)(self, 'authHeader');
     },
+    /**
+     * #getter
+     */
     get tokenType() {
         return (0, configuration_1.getConf)(self, 'tokenType');
     },
+    /**
+     * #getter
+     */
     get domains() {
         return (0, configuration_1.getConf)(self, 'domains');
     },
     /**
+     * #getter
      * Can use this to customize what is displayed in fileSelector's toggle box
      */
     get toggleContents() {
         return null;
     },
     /**
+     * #getter
      * Can use this to customize what the fileSelector. It takes a prop called
      * `setLocation` that should be used to set a UriLocation
      */
@@ -44,6 +74,7 @@ exports.InternetAccount = mobx_state_tree_1.types
         return undefined;
     },
     /**
+     * #getter
      * Can use this to add a label to the UrlChooser. Has no effect if a custom
      * SelectorComponent is supplied
      */
@@ -53,14 +84,16 @@ exports.InternetAccount = mobx_state_tree_1.types
 }))
     .views(self => ({
     /**
+     * #method
      * Determine whether this internetAccount provides credentials for a URL
      * @param location  - UriLocation of resource
      * @returns true or false
      */
     handlesLocation(location) {
-        return self.domains.some((domain) => location === null || location === void 0 ? void 0 : location.uri.includes(domain));
+        return self.domains.some(domain => location === null || location === void 0 ? void 0 : location.uri.includes(domain));
     },
     /**
+     * #getter
      * The key used to store this internetAccount's token in sessionStorage
      */
     get tokenKey() {
@@ -69,6 +102,7 @@ exports.InternetAccount = mobx_state_tree_1.types
 }))
     .actions(self => ({
     /**
+     * #action
      * Must be implemented by a model extending or composing this one. Pass the
      * user's token to `resolve`.
      * @param resolve - Pass the token to this function
@@ -77,16 +111,26 @@ exports.InternetAccount = mobx_state_tree_1.types
     getTokenFromUser(resolve, reject) {
         throw new Error('getTokenFromUser must be implemented by extending model');
     },
+    /**
+     * #action
+     */
     storeToken(token) {
         sessionStorage.setItem(self.tokenKey, token);
     },
+    /**
+     * #action
+     */
     removeToken() {
         sessionStorage.removeItem(self.tokenKey);
     },
+    /**
+     * #action
+     */
     retrieveToken() {
         return sessionStorage.getItem(self.tokenKey);
     },
     /**
+     * #action
      * This can be used by an internetAccount to validate a token works before
      * it is used. This is run when preAuthorizationInformation is requested, so
      * it can be used to check that a token is valid before sending it to a
@@ -95,10 +139,10 @@ exports.InternetAccount = mobx_state_tree_1.types
      * if the original one was invalid. Should throw an error if a token is
      * invalid.
      * @param token - Auth token
-     * @param location - UriLocation of the resource
+     * @param loc - UriLocation of the resource
      * @returns - Valid auth token
      */
-    async validateToken(token, location) {
+    async validateToken(token, loc) {
         return token;
     },
 }))
@@ -106,6 +150,7 @@ exports.InternetAccount = mobx_state_tree_1.types
     let tokenPromise = undefined;
     return {
         /**
+         * #action
          * Try to get the token from the location pre-auth, from local storage,
          * or from a previously cached promise. If token is not available, uses
          * `getTokenFromUser`.
@@ -146,6 +191,9 @@ exports.InternetAccount = mobx_state_tree_1.types
     };
 })
     .actions(self => ({
+    /**
+     * #action
+     */
     addAuthHeaderToInit(init = {}, token) {
         const tokenInfoString = self.tokenType
             ? `${self.tokenType} ${token}`
@@ -155,6 +203,7 @@ exports.InternetAccount = mobx_state_tree_1.types
         return { ...init, headers: newHeaders };
     },
     /**
+     * #action
      * Gets the token and returns it along with the information needed to
      * create a new internetAccount.
      * @param location - UriLocation of the resource
@@ -178,15 +227,16 @@ exports.InternetAccount = mobx_state_tree_1.types
 }))
     .actions(self => ({
     /**
+     * #action
      * Get a fetch method that will add any needed authentication headers to
      * the request before sending it. If location is provided, it will be
      * checked to see if it includes a token in it pre-auth information.
-     * @param location - UriLocation of the resource
+     * @param loc - UriLocation of the resource
      * @returns A function that can be used to fetch
      */
-    getFetcher(location) {
+    getFetcher(loc) {
         return async (input, init) => {
-            const authToken = await self.getToken(location);
+            const authToken = await self.getToken(loc);
             const newInit = self.addAuthHeaderToInit(init, authToken);
             return fetch(input, newInit);
         };
@@ -194,6 +244,7 @@ exports.InternetAccount = mobx_state_tree_1.types
 }))
     .actions(self => ({
     /**
+     * #action
      * Gets a filehandle that uses a fetch that adds auth headers
      * @param location - UriLocation of the resource
      * @returns A filehandle

package/pluggableElementTypes/models/baseConnectionConfig.js

@@ -1,15 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("../../configuration");
+/**
+ * #config BaseConnection
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.default = (0, configuration_1.ConfigurationSchema)('BaseConnection', {
+    /**
+     * #slot
+     */
     name: {
         type: 'string',
         defaultValue: 'nameOfConnection',
         description: 'a unique name for this connection',
     },
+    /**
+     * #slot
+     */
     assemblyNames: {
         type: 'stringArray',
         defaultValue: [],
         description: 'optional list of names of assemblies in this connection',
     },
-}, { explicitlyTyped: true, explicitIdentifier: 'connectionId' });
+}, {
+    explicitlyTyped: true,
+    /**
+     * #identifier
+     */
+    explicitIdentifier: 'connectionId',
+});

package/pluggableElementTypes/models/baseInternetAccountConfig.d.ts

@@ -1,4 +1,4 @@
 import { Instance } from 'mobx-state-tree';
 export declare const BaseInternetAccountConfig: import("../../configuration").AnyConfigurationSchemaType;
-export declare type BaseInternetAccountConfigModel = typeof BaseInternetAccountConfig;
-export declare type BaseInternetAccountConfig = Instance<BaseInternetAccountConfigModel>;
+export type BaseInternetAccountConfigModel = typeof BaseInternetAccountConfig;
+export type BaseInternetAccountConfig = Instance<BaseInternetAccountConfigModel>;

package/pluggableElementTypes/models/baseInternetAccountConfig.js

@@ -2,30 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseInternetAccountConfig = void 0;
 const configuration_1 = require("../../configuration");
+/**
+ * #config InternetAccount
+ * the "base" internet account type
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.BaseInternetAccountConfig = (0, configuration_1.ConfigurationSchema)('InternetAccount', {
+    /**
+     * #slot
+     */
     name: {
         description: 'descriptive name of the internet account',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     description: {
         description: 'a description of the internet account',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     authHeader: {
         description: 'request header for credentials',
         type: 'string',
         defaultValue: 'Authorization',
     },
+    /**
+     * #slot
+     */
     tokenType: {
         description: 'a custom name for a token to include in the header',
         type: 'string',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     domains: {
         description: 'array of valid domains the url can contain to use this account',
         type: 'stringArray',
         defaultValue: [],
     },
-}, { explicitIdentifier: 'internetAccountId', explicitlyTyped: true });
+}, {
+    /**
+     * #identifier
+     */
+    explicitIdentifier: 'internetAccountId',
+    explicitlyTyped: true,
+});

package/pluggableElementTypes/models/baseTrackConfig.d.ts

@@ -1,5 +1,8 @@
 import { Instance } from 'mobx-state-tree';
 import PluginManager from '../../PluginManager';
+/**
+ * #config BaseTrack
+ */
 export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration").AnyConfigurationSchemaType;
-export declare type BaseTrackConfigModel = ReturnType<typeof createBaseTrackConfig>;
-export declare type BaseTrackConfig = Instance<BaseTrackConfigModel>;
+export type BaseTrackConfigModel = ReturnType<typeof createBaseTrackConfig>;
+export type BaseTrackConfig = Instance<BaseTrackConfigModel>;

package/pluggableElementTypes/models/baseTrackConfig.js

@@ -4,74 +4,122 @@ exports.createBaseTrackConfig = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const mobx_state_tree_1 = require("mobx-state-tree");
 const configuration_1 = require("../../configuration");
+/**
+ * #config BaseTrack
+ */
 function createBaseTrackConfig(pluginManager) {
     return (0, configuration_1.ConfigurationSchema)('BaseTrack', {
+        /**
+         * #slot
+         */
         name: {
             description: 'descriptive name of the track',
             type: 'string',
             defaultValue: 'Track',
         },
+        /**
+         * #slot
+         */
         assemblyNames: {
             description: 'name of the assembly (or assemblies) track belongs to',
             type: 'stringArray',
             defaultValue: ['assemblyName'],
         },
+        /**
+         * #slot
+         */
         description: {
             description: 'a description of the track',
             type: 'string',
             defaultValue: '',
         },
+        /**
+         * #slot
+         */
         category: {
             description: 'the category and sub-categories of a track',
             type: 'stringArray',
             defaultValue: [],
         },
+        /**
+         * #slot
+         */
         metadata: {
             type: 'frozen',
             description: 'anything to add about this track',
             defaultValue: {},
         },
+        /**
+         * #slot
+         */
         adapter: pluginManager.pluggableConfigSchemaType('adapter'),
         textSearching: (0, configuration_1.ConfigurationSchema)('textSearching', {
+            /**
+             * #slot textSearching.indexedAttributes
+             */
             indexingAttributes: {
                 type: 'stringArray',
                 description: 'list of which feature attributes to index for text searching',
                 defaultValue: ['Name', 'ID'],
             },
+            /**
+             * #slot textSearching.indexingFeatureTypesToExclude
+             */
             indexingFeatureTypesToExclude: {
                 type: 'stringArray',
                 description: 'list of feature types to exclude in text search index',
                 defaultValue: ['CDS', 'exon'],
             },
+            /**
+             * #slot textSearching.textSearchAdapter
+             */
             textSearchAdapter: pluginManager.pluggableConfigSchemaType('text search adapter'),
         }),
+        /**
+         * #slot
+         */
         displays: mobx_state_tree_1.types.array(pluginManager.pluggableConfigSchemaType('display')),
         formatDetails: (0, configuration_1.ConfigurationSchema)('FormatDetails', {
+            /**
+             * #slot formatDetails.feature
+             */
             feature: {
                 type: 'frozen',
                 description: 'adds extra fields to the feature details',
                 defaultValue: {},
                 contextVariable: ['feature'],
             },
+            /**
+             * #slot formatDetails.subfeatures
+             */
             subfeatures: {
                 type: 'frozen',
                 description: 'adds extra fields to the subfeatures of a feature',
                 defaultValue: {},
                 contextVariable: ['feature'],
             },
+            /**
+             * #slot formatDetails.depth
+             */
             depth: {
                 type: 'number',
                 defaultValue: 2,
-                description: 'depth to iterate on subfeatures',
+                description: 'depth of subfeatures to iterate the formatter on formatDetails.subfeatures (e.g. you may not want to format the exon/cds subfeatures, so limited to 2',
             },
         }),
         formatAbout: (0, configuration_1.ConfigurationSchema)('FormatAbout', {
+            /**
+             * #slot formatAbout.config
+             */
             config: {
                 type: 'frozen',
                 description: 'formats configuration object in about dialog',
                 defaultValue: {},
                 contextVariable: ['config'],
             },
+            /**
+             * #slot formatAbout.hideUris
+             */
             hideUris: {
                 type: 'boolean',
                 defaultValue: false,
@@ -99,6 +147,9 @@ function createBaseTrackConfig(pluginManager) {
             }
             return { ...snap, displays };
         },
+        /**
+         * #identifier
+         */
         explicitIdentifier: 'trackId',
         explicitlyTyped: true,
         actions: (self) => ({

package/pluggableElementTypes/renderers/BoxRendererType.d.ts

@@ -1,9 +1,9 @@
 import GranularRectLayout from '../../util/layouts/GranularRectLayout';
 import MultiLayout from '../../util/layouts/MultiLayout';
+import { SerializedLayout, BaseLayout } from '../../util/layouts/BaseLayout';
 import PrecomputedLayout from '../../util/layouts/PrecomputedLayout';
 import FeatureRendererType, { RenderArgs as FeatureRenderArgs, RenderArgsSerialized as FeatureRenderArgsSerialized, RenderArgsDeserialized as FeatureRenderArgsDeserialized, RenderResults as FeatureRenderResults, ResultsSerialized as FeatureResultsSerialized, ResultsDeserialized as FeatureResultsDeserialized } from './FeatureRendererType';
 import { Region, Feature } from '../../util';
-import { SerializedLayout, BaseLayout } from '../../util/layouts/BaseLayout';
 import { AnyConfigurationModel } from '../../configuration';
 import SerializableFilterChain from './util/serializableFilterChain';
 import RpcManager from '../../rpc/RpcManager';
@@ -12,7 +12,7 @@ export interface LayoutSessionProps {
     bpPerPx: number;
     filters: SerializableFilterChain;
 }
-export declare type MyMultiLayout = MultiLayout<GranularRectLayout<unknown>, unknown>;
+export type MyMultiLayout = MultiLayout<GranularRectLayout<unknown>, unknown>;
 export interface CachedLayout {
     layout: MyMultiLayout;
     config: AnyConfigurationModel;

package/pluggableElementTypes/renderers/BoxRendererType.js

@@ -5,9 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayoutSession = void 0;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+// layouts
 const GranularRectLayout_1 = __importDefault(require("../../util/layouts/GranularRectLayout"));
 const MultiLayout_1 = __importDefault(require("../../util/layouts/MultiLayout"));
 const PrecomputedLayout_1 = __importDefault(require("../../util/layouts/PrecomputedLayout"));
+// other
 const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
 const util_1 = require("../../util");
 const configuration_1 = require("../../configuration");

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.d.ts

@@ -14,7 +14,7 @@ export interface RenderArgsDeserialized extends ServerSideRenderArgsDeserialized
     blockKey: string;
 }
 export type { RenderResults };
-export declare type ResultsSerialized = ServerSideResultsSerialized;
+export type ResultsSerialized = ServerSideResultsSerialized;
 export interface ResultsDeserialized extends ServerSideResultsDeserialized {
     blockKey: string;
 }

package/pluggableElementTypes/renderers/RendererType.d.ts

@@ -3,7 +3,7 @@ import PluggableElementBase from '../PluggableElementBase';
 import { AnyConfigurationSchemaType } from '../../configuration/configurationSchema';
 import { AnyReactComponentType } from '../../util';
 import PluginManager from '../../PluginManager';
-export declare type RenderProps = Record<string, unknown>;
+export type RenderProps = Record<string, unknown>;
 export interface RenderResults {
     reactElement?: ReactElement;
     html?: string;

package/pluggableElementTypes/renderers/ServerSideRendererType.d.ts

@@ -35,7 +35,7 @@ export interface ResultsSerializedSvgExport extends ResultsSerialized {
     height: number;
     reactElement: unknown;
 }
-export declare type ResultsDeserialized = RenderResults;
+export type ResultsDeserialized = RenderResults;
 export default class ServerSideRenderer extends RendererType {
     /**
      * directly modifies the render arguments to prepare them to be serialized and

package/pluggableElementTypes/renderers/util/serializableFilterChain.d.ts

@@ -1,9 +1,9 @@
-declare type FilterExpression = (...args: Record<string, any>[] | any[]) => boolean;
+type FilterExpression = (...args: Record<string, any>[] | any[]) => boolean;
 interface Filter {
     string: string;
     expr: FilterExpression;
 }
-export declare type SerializedFilterChain = string[];
+export type SerializedFilterChain = string[];
 export default class SerializableFilterChain {
     filterChain: Filter[];
     constructor({ filters }: {

package/rpc/MainThreadRpcDriver.d.ts

@@ -13,6 +13,6 @@ export default class MainThreadRpcDriver extends BaseRpcDriver {
     name: string;
     makeWorker: () => Promise<DummyHandle>;
     constructor(args: RpcDriverConstructorArgs);
-    call(pluginManager: PluginManager, sessionId: string, functionName: string, args: {}): Promise<unknown>;
+    call(pm: PluginManager, sessionId: string, funcName: string, args: {}): Promise<unknown>;
 }
 export {};

package/rpc/MainThreadRpcDriver.js

@@ -21,11 +21,11 @@ class MainThreadRpcDriver extends BaseRpcDriver_1.default {
         this.name = 'MainThreadRpcDriver';
         this.makeWorker = async () => new DummyHandle();
     }
-    async call(pluginManager, sessionId, functionName, args) {
+    async call(pm, sessionId, funcName, args) {
         if (!sessionId) {
             throw new TypeError('sessionId is required');
         }
-        const rpcMethod = pluginManager.getRpcMethodType(functionName);
+        const rpcMethod = pm.getRpcMethodType(funcName);
         const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
         const result = await rpcMethod.execute(serializedArgs, this.name);
         return rpcMethod.deserializeReturn(result, args, this.name);

package/rpc/RpcManager.d.ts

@@ -2,8 +2,8 @@ import PluginManager from '../PluginManager';
 import { AnyConfigurationModel } from '../configuration';
 import WebWorkerRpcDriver from './WebWorkerRpcDriver';
 import MainThreadRpcDriver from './MainThreadRpcDriver';
-declare type DriverClass = WebWorkerRpcDriver | MainThreadRpcDriver;
-declare type BackendConfigurations = {
+type DriverClass = WebWorkerRpcDriver | MainThreadRpcDriver;
+type BackendConfigurations = {
     WebWorkerRpcDriver?: Omit<ConstructorParameters<typeof WebWorkerRpcDriver>[0], 'config'>;
     MainThreadRpcDriver?: Omit<ConstructorParameters<typeof MainThreadRpcDriver>[0], 'config'>;
 };

package/rpc/WebWorkerRpcDriver.d.ts

@@ -4,12 +4,13 @@ import { PluginDefinition } from '../PluginLoader';
 interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
     makeWorkerInstance: () => Worker;
 }
+interface Options {
+    statusCallback?: (arg0: string) => void;
+    rpcDriverClassName: string;
+}
 declare class WebWorkerHandle extends Rpc.Client {
     destroy(): void;
-    call(functionName: string, args: Record<string, unknown>, opts: {
-        statusCallback?: (arg0: string) => void;
-        rpcDriverClassName: string;
-    }): Promise<any>;
+    call(funcName: string, args: Record<string, unknown>, opts: Options): Promise<any>;
 }
 export default class WebWorkerRpcDriver extends BaseRpcDriver {
     workerBootConfiguration: {

package/rpc/WebWorkerRpcDriver.js

@@ -12,14 +12,14 @@ class WebWorkerHandle extends librpc_web_mod_1.default.Client {
     destroy() {
         this.workers[0].terminate();
     }
-    async call(functionName, args, opts) {
+    async call(funcName, args, opts) {
         const { statusCallback, rpcDriverClassName } = opts;
         const channel = `message-${shortid_1.default.generate()}`;
         const listener = (message) => {
             statusCallback === null || statusCallback === void 0 ? void 0 : statusCallback(message);
         };
         this.on(channel, listener);
-        const result = await super.call(functionName, { ...args, channel, rpcDriverClassName }, opts);
+        const result = await super.call(funcName, { ...args, channel, rpcDriverClassName }, opts);
         this.off(channel, listener);
         return result;
     }

package/rpc/baseRpcConfig.d.ts

@@ -0,0 +1,2 @@
+declare const BaseRpcDriverConfigSchema: import("../configuration").AnyConfigurationSchemaType;
+export default BaseRpcDriverConfigSchema;

package/rpc/baseRpcConfig.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configuration_1 = require("../configuration");
+/**
+ * #config BaseRpcDriver
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+const BaseRpcDriverConfigSchema = (0, configuration_1.ConfigurationSchema)('BaseRpcDriver', {
+    /**
+     * #slot
+     */
+    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.js

@@ -1,23 +1,29 @@
 "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 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 });
-const MainThreadRpcDriverConfigSchema = (0, configuration_1.ConfigurationSchema)('MainThreadRpcDriver', {}, { explicitlyTyped: true, baseConfiguration: BaseRpcDriverConfigSchema });
-const WebWorkerRpcDriverConfigSchema = (0, configuration_1.ConfigurationSchema)('WebWorkerRpcDriver', {}, { explicitlyTyped: true, baseConfiguration: BaseRpcDriverConfigSchema });
+const webWorkerRpcConfig_1 = __importDefault(require("./webWorkerRpcConfig"));
+const mainThreadRpcConfig_1 = __importDefault(require("./mainThreadRpcConfig"));
+/**
+ * #config RpcOptions
+ */
+function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
 exports.default = (0, configuration_1.ConfigurationSchema)('RpcOptions', {
+    /**
+     * #slot
+     */
     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(MainThreadRpcDriverConfigSchema, WebWorkerRpcDriverConfigSchema)), {
+    /**
+     * #slot
+     */
+    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' },
     }),