@jbrowse/core 2.2.2 → 2.3.1

package/PluginManager.d.ts

@@ -98,7 +98,11 @@ export default class PluginManager {
     addElementType(groupName: PluggableElementTypeGroup, creationCallback: (pluginManager: PluginManager) => PluggableElementType): this;
     getElementType(groupName: PluggableElementTypeGroup, typeName: string): PluggableElementBase;
     getElementTypesInGroup(groupName: PluggableElementTypeGroup): PluggableElementBase[];
+    getTrackElements(): TrackType[];
+    getAddTrackWorkflowElements(): AddTrackWorkflowType[];
     getRpcElements(): RpcMethodType[];
+    getDisplayElements(): DisplayType[];
+    getAdapterElements(): AdapterType[];
     /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName: PluggableElementTypeGroup, fieldName: PluggableElementMember, fallback?: IAnyType): IAnyType;
     /** get a MST type for the union of all specified pluggable config schemas */

package/PluginManager.js

@@ -234,9 +234,21 @@ class PluginManager {
     getElementTypesInGroup(groupName) {
         return this.getElementTypeRecord(groupName).all();
     }
+    getTrackElements() {
+        return this.getElementTypesInGroup('track');
+    }
+    getAddTrackWorkflowElements() {
+        return this.getElementTypesInGroup('add track workflow');
+    }
     getRpcElements() {
         return this.getElementTypesInGroup('rpc method');
     }
+    getDisplayElements() {
+        return this.getElementTypesInGroup('display');
+    }
+    getAdapterElements() {
+        return this.getElementTypesInGroup('adapter');
+    }
     /** get a MST type for the union of all specified pluggable MST types */
     pluggableMstType(groupName, fieldName, fallback = mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.null)) {
         const pluggableTypes = this.getElementTypeRecord(groupName)

package/README.md

@@ -1,7 +1,8 @@
 # jbrowse-core
 
 [![NPM version](https://img.shields.io/npm/v/@jbrowse/core.svg?style=flat-square)](https://npmjs.org/package/@jbrowse/core)
-[![Build Status](https://img.shields.io/travis/GMOD/jbrowse-components/main.svg?style=flat-square)](https://travis-ci.org/GMOD/jbrowse-components) [![Coverage Status](https://img.shields.io/codecov/c/github/GMOD/jbrowse-components/main.svg?style=flat-square)](https://codecov.io/gh/GMOD/jbrowse-components/branch/main)
+[![Build Status](https://img.shields.io/travis/GMOD/jbrowse-components/main.svg?style=flat-square)](https://travis-ci.org/GMOD/jbrowse-components)
+[![Coverage Status](https://img.shields.io/codecov/c/github/GMOD/jbrowse-components/main.svg?style=flat-square)](https://codecov.io/gh/GMOD/jbrowse-components/branch/main)
 
 Core JBrowse libraries used by most JBrowse plugins.
 
@@ -11,7 +12,10 @@ See [docs](docs/README.md)
 
 ## Academic Use
 
-This package was written with funding from the [NHGRI](http://genome.gov) as part of the [JBrowse](http://jbrowse.org) project. If you use it in an academic project that you publish, please cite the most recent JBrowse paper, which will be linked from [jbrowse.org](http://jbrowse.org).
+This package was written with funding from the [NHGRI](http://genome.gov) as
+part of the [JBrowse](http://jbrowse.org) project. If you use it in an academic
+project that you publish, please cite the most recent JBrowse paper, which will
+be linked from [jbrowse.org](http://jbrowse.org).
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "2.2.2",
+  "version": "2.3.1",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
     "jbrowse",
@@ -67,11 +67,11 @@
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0",
     "rxjs": "^6.0.0",
-    "tss-react": "^3.0.0"
+    "tss-react": "^4.0.0"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
-  "gitHead": "abbc00e8feedbc58de84a7a3e735ec0224909b29"
+  "gitHead": "75c4cba2f50c626c62881abd5851dbf2435c2401"
 }

package/pluggableElementTypes/AdapterType.d.ts

@@ -2,10 +2,9 @@ import PluggableElementBase from './PluggableElementBase';
 import { AnyConfigurationSchemaType } from '../configuration/configurationSchema';
 import { AnyAdapter } from '../data_adapters/BaseAdapter';
 export type AdapterMetadata = {
-    category: string | null;
-    hiddenFromGUI: boolean | null;
-    displayName: string | null;
-    description: string | null;
+    category?: string;
+    hiddenFromGUI?: boolean;
+    description?: string;
 };
 export default class AdapterType extends PluggableElementBase {
     AdapterClass?: AnyAdapter;
@@ -16,6 +15,7 @@ export default class AdapterType extends PluggableElementBase {
     constructor(stuff: {
         name: string;
         configSchema: AnyConfigurationSchemaType;
+        displayName?: string;
         adapterCapabilities?: string[];
         adapterMetadata?: AdapterMetadata;
     } & ({

package/pluggableElementTypes/AdapterType.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint curly:error */
 const PluggableElementBase_1 = __importDefault(require("./PluggableElementBase"));
 class AdapterType extends PluggableElementBase_1.default {
     constructor(stuff) {

package/pluggableElementTypes/AddTrackWorkflowType.d.ts

@@ -4,13 +4,13 @@ import PluggableElementBase from './PluggableElementBase';
 type BasicComponent = React.ComponentType<{
     model: any;
 }>;
-type AddTrackWorkflowComponent = React.LazyExoticComponent<BasicComponent> | BasicComponent;
+type AddTrackWorkflowComponentType = React.LazyExoticComponent<BasicComponent> | BasicComponent;
 export default class AddTrackWorkflow extends PluggableElementBase {
-    ReactComponent: AddTrackWorkflowComponent;
+    ReactComponent: AddTrackWorkflowComponentType;
     stateModel: IAnyModelType;
     constructor(stuff: {
         name: string;
-        ReactComponent: AddTrackWorkflowComponent;
+        ReactComponent: AddTrackWorkflowComponentType;
         stateModel: IAnyModelType;
     });
 }

package/pluggableElementTypes/ConnectionType.d.ts

@@ -5,7 +5,6 @@ import { AnyReactComponentType } from '../util';
 export default class ConnectionType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;
-    displayName: string;
     description: string;
     url: string;
     configEditorComponent?: AnyReactComponentType;

package/pluggableElementTypes/ConnectionType.js

@@ -9,7 +9,6 @@ class ConnectionType extends PluggableElementBase_1.default {
         super(stuff);
         this.stateModel = stuff.stateModel;
         this.configSchema = stuff.configSchema;
-        this.displayName = stuff.displayName;
         this.description = stuff.description;
         this.url = stuff.url;
         this.configEditorComponent = stuff.configEditorComponent;

package/pluggableElementTypes/DisplayType.d.ts

@@ -6,13 +6,22 @@ export default class DisplayType extends PluggableElementBase {
     stateModel: IAnyModelType;
     configSchema: AnyConfigurationSchemaType;
     ReactComponent: AnyReactComponentType;
+    /**
+     * The track type the display is associated with
+     */
     trackType: string;
+    subDisplay?: unknown;
+    /**
+     * The view type the display is associated with
+     */
     viewType: string;
     constructor(stuff: {
         name: string;
         stateModel: IAnyModelType;
         trackType: string;
         viewType: string;
+        displayName?: string;
+        subDisplay?: unknown;
         configSchema: AnyConfigurationSchemaType;
         ReactComponent: AnyReactComponentType;
     });

package/pluggableElementTypes/DisplayType.js

@@ -9,6 +9,7 @@ class DisplayType extends PluggableElementBase_1.default {
     constructor(stuff) {
         super(stuff);
         this.stateModel = stuff.stateModel;
+        this.subDisplay = stuff.subDisplay;
         this.configSchema = stuff.configSchema;
         this.ReactComponent = stuff.ReactComponent;
         this.trackType = stuff.trackType;

package/pluggableElementTypes/PluggableElementBase.d.ts

@@ -1,6 +1,9 @@
 export default abstract class PluggableElementBase {
     name: string;
+    maybeDisplayName?: string;
     constructor(args: {
         name: string;
+        displayName?: string;
     });
+    get displayName(): string;
 }

package/pluggableElementTypes/PluggableElementBase.js

@@ -4,6 +4,10 @@ class PluggableElementBase {
     constructor(args) {
         this.name = '';
         this.name = args.name;
+        this.maybeDisplayName = args.displayName;
+    }
+    get displayName() {
+        return this.maybeDisplayName || this.name;
     }
 }
 exports.default = PluggableElementBase;

package/pluggableElementTypes/TextSearchAdapterType.d.ts

@@ -7,6 +7,7 @@ export default class TextSearchAdapterType extends PluggableElementBase {
     description?: string;
     constructor(stuff: {
         name: string;
+        displayName?: string;
         description?: string;
         configSchema: AnyConfigurationSchemaType;
         AdapterClass: AnyAdapter;

package/pluggableElementTypes/TrackType.d.ts

@@ -1,6 +1,6 @@
 import { IAnyModelType } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration/configurationSchema';
+import { AnyConfigurationSchemaType } from '../configuration';
 import DisplayType from './DisplayType';
 export default class TrackType extends PluggableElementBase {
     stateModel: IAnyModelType;
@@ -9,6 +9,7 @@ export default class TrackType extends PluggableElementBase {
     constructor(stuff: {
         name: string;
         stateModel: IAnyModelType;
+        displayName?: string;
         configSchema: AnyConfigurationSchemaType;
     });
     addDisplayType(display: DisplayType): void;

package/pluggableElementTypes/ViewType.d.ts

@@ -6,15 +6,16 @@ type BasicView = React.ComponentType<{
     model: any;
     session?: IAnyStateTreeNode;
 }>;
-type ViewReactComponent = React.LazyExoticComponent<BasicView> | BasicView;
+type ViewComponentType = React.LazyExoticComponent<BasicView> | BasicView;
 export default class ViewType extends PluggableElementBase {
-    ReactComponent: ViewReactComponent;
+    ReactComponent: ViewComponentType;
     stateModel: IAnyModelType;
     displayTypes: DisplayType[];
     extendedName?: string;
     constructor(stuff: {
         name: string;
-        ReactComponent: ViewReactComponent;
+        displayName?: string;
+        ReactComponent: ViewComponentType;
         stateModel: IAnyModelType;
         extendedName?: string;
     });

package/pluggableElementTypes/WidgetType.d.ts

@@ -1,23 +1,24 @@
 import React, { ComponentType, LazyExoticComponent } from 'react';
 import { IAnyModelType, IAnyStateTreeNode } from 'mobx-state-tree';
 import PluggableElementBase from './PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../configuration/configurationSchema';
+import { AnyConfigurationSchemaType } from '../configuration';
+type WidgetComponentType = LazyExoticComponent<React.FC<any>> | React.FC<any>;
+type HeadingComponentType = ComponentType<{
+    model: IAnyStateTreeNode;
+}>;
 export default class WidgetType extends PluggableElementBase {
     heading?: string;
     configSchema: AnyConfigurationSchemaType;
-    HeadingComponent?: ComponentType<{
-        model: IAnyStateTreeNode;
-    }>;
-    ReactComponent: LazyExoticComponent<React.FC<any>> | React.FC<any>;
+    HeadingComponent?: HeadingComponentType;
+    ReactComponent: WidgetComponentType;
     stateModel: IAnyModelType;
     constructor(stuff: {
         name: string;
         heading?: string;
-        HeadingComponent?: ComponentType<{
-            model: IAnyStateTreeNode;
-        }>;
+        HeadingComponent?: HeadingComponentType;
         configSchema: AnyConfigurationSchemaType;
         stateModel: IAnyModelType;
-        ReactComponent: LazyExoticComponent<React.FC<any>> | React.FC<any>;
+        ReactComponent: WidgetComponentType;
     });
 }
+export {};

package/pluggableElementTypes/models/BaseDisplayModel.js

@@ -72,6 +72,7 @@ function stateModelFactory() {
         renderProps() {
             return {
                 ...(0, tracks_1.getParentRenderProps)(self),
+                notReady: (0, util_1.getContainingView)(self).minimized,
                 rpcDriverName: self.rpcDriverName,
                 displayModel: self,
             };

package/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -1,15 +1,17 @@
-import { Instance } from 'mobx-state-tree';
+import { Instance, IAnyStateTreeNode } from 'mobx-state-tree';
 import { AnyConfigurationSchemaType } from '../../configuration';
 import PluginManager from '../../PluginManager';
 import { MenuItem } from '../../ui';
+export declare function getCompatibleDisplays(self: IAnyStateTreeNode): ({
+    [x: string]: any;
+} & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+    setSubschema(slotName: string, data: unknown): any;
+} & import("mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>)[];
 /**
  * #stateModel BaseTrackModel
- * these MST models only exist for tracks that are *shown*.
- * they should contain only UI state for the track, and have
- * a reference to a track configuration (stored under
- * session.configuration.assemblies.get(assemblyName).tracks).
- * note that multiple displayed tracks could use the same
- * configuration.
+ * these MST models only exist for tracks that are *shown*. they should contain
+ * only UI state for the track, and have a reference to a track configuration.
+ * note that multiple displayed tracks could use the same configuration.
  */
 export declare function createBaseTrackModel(pm: PluginManager, trackType: string, baseTrackConfig: AnyConfigurationSchemaType): import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
@@ -68,7 +70,16 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     /**
      * #method
      */
-    trackMenuItems(): MenuItem[];
+    trackMenuItems(): (import("../../ui").MenuDivider | import("../../ui").MenuSubHeader | import("../../ui").NormalMenuItem | import("../../ui").CheckboxMenuItem | import("../../ui").RadioMenuItem | import("../../ui").SubMenuItem | {
+        type: string;
+        label: string;
+        subMenu: {
+            type: string;
+            label: string;
+            checked: boolean;
+            onClick: () => void;
+        }[];
+    })[];
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type BaseTrackStateModel = ReturnType<typeof createBaseTrackModel>;
 export type BaseTrackModel = Instance<BaseTrackStateModel>;

package/pluggableElementTypes/models/BaseTrackModel.js

@@ -1,20 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBaseTrackModel = void 0;
+exports.createBaseTrackModel = exports.getCompatibleDisplays = void 0;
 const mobx_1 = require("mobx");
 const mobx_state_tree_1 = require("mobx-state-tree");
+// locals
 const configuration_1 = require("../../configuration");
 const util_1 = require("../../util");
 const types_1 = require("../../util/types");
 const mst_1 = require("../../util/types/mst");
+function getCompatibleDisplays(self) {
+    const { pluginManager } = (0, util_1.getEnv)(self);
+    const view = (0, util_1.getContainingView)(self);
+    const viewType = pluginManager.getViewType(view.type);
+    const compatTypes = viewType.displayTypes.map(d => d.name);
+    const displays = self.configuration.displays;
+    return displays.filter(d => compatTypes.includes(d.type));
+}
+exports.getCompatibleDisplays = getCompatibleDisplays;
 /**
  * #stateModel BaseTrackModel
- * these MST models only exist for tracks that are *shown*.
- * they should contain only UI state for the track, and have
- * a reference to a track configuration (stored under
- * session.configuration.assemblies.get(assemblyName).tracks).
- * note that multiple displayed tracks could use the same
- * configuration.
+ * these MST models only exist for tracks that are *shown*. they should contain
+ * only UI state for the track, and have a reference to a track configuration.
+ * note that multiple displayed tracks could use the same configuration.
  */
 function createBaseTrackModel(pm, trackType, baseTrackConfig) {
     return mobx_state_tree_1.types
@@ -111,9 +118,7 @@ function createBaseTrackModel(pm, trackType, baseTrackConfig) {
                 // @ts-ignore
                 const trackConf = session.editTrackConfiguration(self.configuration);
                 if (trackConf && trackConf !== self.configuration) {
-                    // @ts-ignore
                     view.hideTrack(self.configuration);
-                    // @ts-ignore
                     view.showTrack(trackConf);
                 }
             }
@@ -174,24 +179,25 @@ function createBaseTrackModel(pm, trackType, baseTrackConfig) {
             const menuItems = self.displays
                 .map(d => d.trackMenuItems())
                 .flat();
-            const displayChoices = [];
-            const view = (0, util_1.getContainingView)(self);
-            const viewType = pm.getViewType(view.type);
-            const compatibleDisplayTypes = viewType.displayTypes.map(d => d.name);
-            const compatibleDisplays = self.configuration.displays.filter((d) => compatibleDisplayTypes.includes(d.type));
             const shownId = self.displays[0].configuration.displayId;
-            if (compatibleDisplays.length > 1) {
-                displayChoices.push({ type: 'divider' }, { type: 'subHeader', label: 'Display types' });
-                compatibleDisplays.forEach((displayConf) => {
-                    displayChoices.push({
-                        type: 'radio',
-                        label: displayConf.type,
-                        checked: displayConf.displayId === shownId,
-                        onClick: () => self.replaceDisplay(shownId, displayConf.displayId),
-                    });
-                });
-            }
-            return [...menuItems, ...displayChoices];
+            const compatDisp = getCompatibleDisplays(self);
+            return [
+                ...menuItems,
+                ...(compatDisp.length > 1
+                    ? [
+                        {
+                            type: 'subMenu',
+                            label: 'Display types',
+                            subMenu: compatDisp.map(d => ({
+                                type: 'radio',
+                                label: pm.getDisplayType(d.type).displayName,
+                                checked: d.displayId === shownId,
+                                onClick: () => self.replaceDisplay(shownId, d.displayId),
+                            })),
+                        },
+                    ]
+                    : []),
+            ];
         },
     }));
 }

package/pluggableElementTypes/renderers/BoxRendererType.js

@@ -108,20 +108,7 @@ class BoxRendererType extends FeatureRendererType_1.default {
     }
     deserializeResultsInClient(result, args) {
         const layout = this.deserializeLayoutInClient(result.layout);
-        const deserialized = super.deserializeResultsInClient({ ...result, layout }, args);
-        // // debugging aid: check if there are features in `features` that are not in the layout
-        // const featureIds1 = iterMap(deserialized.features.values(), f =>
-        //   f.id(),
-        // ).sort()
-        // const featureIds2 = Object.keys(
-        //   deserialized.layout.toJSON().rectangles,
-        // ).sort()
-        // if (
-        //   featureIds1.length > featureIds2.length &&
-        //   !deserialized.layout.maxHeightReached
-        // )
-        //   debugger
-        return deserialized;
+        return super.deserializeResultsInClient({ ...result, layout }, args);
     }
     createLayoutInWorker(args) {
         const { regions } = args;

package/pluggableElementTypes/renderers/CircularChordRendererType.d.ts

@@ -1,3 +1,12 @@
+import { SimpleFeatureSerialized } from '../../util/simpleFeature';
 import FeatureRenderer from './FeatureRendererType';
 export default class CircularChordRendererType extends FeatureRenderer {
+    deserializeResultsInClient(res: {
+        features: SimpleFeatureSerialized[];
+        html: string;
+    }, args: {
+        exportSVG?: {
+            rasterizeLayers?: boolean;
+        };
+    }): any;
 }

package/pluggableElementTypes/renderers/CircularChordRendererType.js

@@ -3,7 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
 const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
+const RpcRenderedSvgGroup_1 = __importDefault(require("./RpcRenderedSvgGroup"));
 class CircularChordRendererType extends FeatureRendererType_1.default {
+    deserializeResultsInClient(res, args) {
+        const deserializedFeatures = new Map(res.features.map(f => simpleFeature_1.default.fromJSON(f)).map(f => [f.id(), f]));
+        // if we are rendering svg, we skip hydration
+        if (args.exportSVG) {
+            // only return the res if the renderer explicitly has
+            // this.supportsSVG support to avoid garbage being rendered in SVG
+            // document
+            return {
+                ...res,
+                html: this.supportsSVG
+                    ? res.html
+                    : '<text y="12" fill="black">SVG export not supported for this track</text>',
+            };
+        }
+        // hydrate res using ServerSideRenderedContent
+        return {
+            ...res,
+            reactElement: (react_1.default.createElement(RpcRenderedSvgGroup_1.default, { ...args, ...res, features: deserializedFeatures, RenderingComponent: this.ReactComponent })),
+        };
+    }
 }
 exports.default = CircularChordRendererType;

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const operators_1 = require("rxjs/operators");
 const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererType"));
 const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const util_1 = require("../../util");
 class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
     /**
      * directly modifies the render arguments to prepare
@@ -77,10 +78,12 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
             return requestRegion;
         });
         // note that getFeaturesInMultipleRegions does not do glyph expansion
-        return dataAdapter
+        const res = await dataAdapter
             .getFeaturesInMultipleRegions(requestRegions, renderArgs)
             .pipe((0, operators_1.filter)(f => this.featurePassesFilters(renderArgs, f)), (0, operators_1.toArray)())
             .toPromise();
+        // dedupe needed xref https://github.com/GMOD/jbrowse-components/pull/3404/
+        return (0, util_1.dedupe)(res, f => f.id());
     }
 }
 exports.default = ComparativeServerSideRenderer;

package/pluggableElementTypes/renderers/FeatureRendererType.d.ts

@@ -39,10 +39,10 @@ export interface ResultsDeserialized extends ServerSideResultsDeserialized {
 }
 export default class FeatureRendererType extends ServerSideRendererType {
     /**
-     * replaces the `displayModel` param (which on the client is a MST model) with
-     * a stub that only contains the `selectedFeature`, since this is the only
-     * part of the track model that most renderers read. also serializes the
-     * config and regions to JSON from MST objects.
+     * replaces the `displayModel` param (which on the client is a MST model)
+     * with a stub that only contains the `selectedFeature`, since this is the only
+     * part of the track model that most renderers read. also serializes the config
+     * and regions to JSON from MST objects.
      *
      * @param args - the arguments passed to render
      */

package/pluggableElementTypes/renderers/FeatureRendererType.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const operators_1 = require("rxjs/operators");
+const clone_1 = __importDefault(require("clone"));
 const util_1 = require("../../util");
 const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
 const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
@@ -11,10 +12,10 @@ const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererTy
 const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
 class FeatureRendererType extends ServerSideRendererType_1.default {
     /**
-     * replaces the `displayModel` param (which on the client is a MST model) with
-     * a stub that only contains the `selectedFeature`, since this is the only
-     * part of the track model that most renderers read. also serializes the
-     * config and regions to JSON from MST objects.
+     * replaces the `displayModel` param (which on the client is a MST model)
+     * with a stub that only contains the `selectedFeature`, since this is the only
+     * part of the track model that most renderers read. also serializes the config
+     * and regions to JSON from MST objects.
      *
      * @param args - the arguments passed to render
      */
@@ -26,7 +27,7 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
                 id: displayModel.id,
                 selectedFeatureId: displayModel.selectedFeatureId,
             },
-            regions: JSON.parse(JSON.stringify(regions)),
+            regions: (0, clone_1.default)(regions),
         };
         return super.serializeArgsInClient(serializedArgs);
     }
@@ -37,11 +38,7 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
      * @param args - the arguments passed to render
      */
     deserializeResultsInClient(result, args) {
-        const deserializedFeatures = new Map();
-        result.features.forEach(j => {
-            const f = simpleFeature_1.default.fromJSON(j);
-            deserializedFeatures.set(String(f.id()), f);
-        });
+        const deserializedFeatures = new Map(result.features.map(f => simpleFeature_1.default.fromJSON(f)).map(f => [f.id(), f]));
         const deserialized = super.deserializeResultsInClient({
             ...result,
             features: deserializedFeatures,
@@ -83,8 +80,9 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
      * @returns Map of features as `{ id => feature, ... }`
      */
     async getFeatures(renderArgs) {
+        const pm = this.pluginManager;
         const { signal, regions, sessionId, adapterConfig } = renderArgs;
-        const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(this.pluginManager, sessionId, adapterConfig);
+        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');
         }
@@ -92,9 +90,9 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
         if (!regions || regions.length === 0) {
             return features;
         }
+        // make sure the requested region's start and end are integers, if
+        // there is a region specification.
         const requestRegions = regions.map((r) => {
-            // make sure the requested region's start and end are integers, if
-            // there is a region specification.
             const requestRegion = { ...r };
             if (requestRegion.start) {
                 requestRegion.start = Math.floor(requestRegion.start);

package/pluggableElementTypes/renderers/RendererType.d.ts

@@ -16,6 +16,7 @@ export default class RendererType extends PluggableElementBase {
     constructor(stuff: {
         name: string;
         ReactComponent: AnyReactComponentType;
+        displayName?: string;
         configSchema: AnyConfigurationSchemaType;
         pluginManager: PluginManager;
     });

package/pluggableElementTypes/renderers/RpcRenderedSvgGroup.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { AnyReactComponentType, Feature } from '../../util';
+declare const _default: (props: {
+    html: string;
+    features: Map<string, Feature>;
+    RenderingComponent: AnyReactComponentType;
+}) => JSX.Element;
+export default _default;