@jbrowse/core 2.17.0 → 2.18.0

package/pluggableElementTypes/models/baseTrackConfig.js

@@ -3,111 +3,66 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBaseTrackConfig = createBaseTrackConfig;
 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 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',
             },
-            /**
-             * #slot formatDetails.maxDepth
-             */
             maxDepth: {
                 type: 'number',
                 defaultValue: 99999,
@@ -115,18 +70,12 @@ function createBaseTrackConfig(pluginManager) {
             },
         }),
         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,
@@ -134,12 +83,9 @@ function createBaseTrackConfig(pluginManager) {
         }),
     }, {
         preProcessSnapshot: s2 => {
-            const snap = pluginManager.evaluateExtensionPoint('Core-preProcessTrackConfig', JSON.parse(JSON.stringify(s2)));
+            const snap = pluginManager.evaluateExtensionPoint('Core-preProcessTrackConfig', structuredClone(s2));
             const { displays = [] } = snap;
             if (snap.trackId !== 'placeholderId') {
-                // Gets the displays on the track snapshot and the possible displays
-                // from the track type and adds any missing possible displays to the
-                // snapshot
                 const configDisplayTypes = new Set(displays.map(d => d.type));
                 pluginManager.getTrackType(snap.type).displayTypes.forEach(d => {
                     if (!configDisplayTypes.has(d.name)) {
@@ -152,9 +98,6 @@ function createBaseTrackConfig(pluginManager) {
             }
             return { ...snap, displays };
         },
-        /**
-         * #identifier
-         */
         explicitIdentifier: 'trackId',
         explicitlyTyped: true,
         actions: (self) => ({

package/pluggableElementTypes/renderers/BoxRendererType.d.ts

@@ -1,12 +1,13 @@
+import FeatureRendererType from './FeatureRendererType';
 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 { AnyConfigurationModel } from '../../configuration';
-import SerializableFilterChain from './util/serializableFilterChain';
-import RpcManager from '../../rpc/RpcManager';
+import type { RenderArgs as FeatureRenderArgs, RenderArgsDeserialized as FeatureRenderArgsDeserialized, RenderArgsSerialized as FeatureRenderArgsSerialized, RenderResults as FeatureRenderResults, ResultsDeserialized as FeatureResultsDeserialized, ResultsSerialized as FeatureResultsSerialized } from './FeatureRendererType';
+import type { AnyConfigurationModel } from '../../configuration';
+import type { Feature, Region } from '../../util';
+import type SerializableFilterChain from './util/serializableFilterChain';
+import type RpcManager from '../../rpc/RpcManager';
+import type { BaseLayout, SerializedLayout } from '../../util/layouts/BaseLayout';
 export interface LayoutSessionProps {
     config: AnyConfigurationModel;
     bpPerPx: number;
@@ -25,10 +26,6 @@ export declare class LayoutSession implements LayoutSessionProps {
     constructor(args: LayoutSessionProps);
     update(props: LayoutSessionProps): void;
     makeLayout(): MultiLayout<GranularRectLayout<unknown>, unknown>;
-    /**
-     * @param layout -
-     * @returns true if the given layout is a valid one to use for this session
-     */
     cachedLayoutIsValid(cachedLayout: CachedLayout): boolean;
     cachedLayout: CachedLayout | undefined;
     get layout(): MyMultiLayout;
@@ -74,10 +71,5 @@ export default class BoxRendererType extends FeatureRendererType {
     deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
     createLayoutInWorker(args: RenderArgsDeserialized): GranularRectLayout<unknown>;
     serializeResultsInWorker(results: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
-    /**
-     * gets layout and renders
-     *
-     * @param props - render args
-     */
     render(props: RenderArgsDeserialized): Promise<RenderResults>;
 }

package/pluggableElementTypes/renderers/BoxRendererType.js

@@ -5,14 +5,12 @@ 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 FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
+const configuration_1 = require("../../configuration");
+const util_1 = require("../../util");
 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");
 class LayoutSession {
     constructor(args) {
         this.config = args.config;
@@ -31,10 +29,6 @@ class LayoutSession {
             pitchY: (0, configuration_1.readConfObject)(this.config, 'noSpacing') ? 1 : 3,
         });
     }
-    /**
-     * @param layout -
-     * @returns true if the given layout is a valid one to use for this session
-     */
     cachedLayoutIsValid(cachedLayout) {
         return (cachedLayout.layout.subLayoutConstructorArgs.pitchX === this.bpPerPx &&
             (0, fast_deep_equal_1.default)((0, configuration_1.readConfObject)(this.config), cachedLayout.config) &&
@@ -111,11 +105,6 @@ class BoxRendererType extends FeatureRendererType_1.default {
         serialized.maxHeightReached = serialized.layout.maxHeightReached;
         return serialized;
     }
-    /**
-     * gets layout and renders
-     *
-     * @param props - render args
-     */
     async render(props) {
         const layout = props.layout ||
             this.createLayoutInWorker(props);

package/pluggableElementTypes/renderers/CircularChordRendererType.d.ts

@@ -1,7 +1,8 @@
 import React from 'react';
-import { SimpleFeature, SimpleFeatureSerialized } from '../../util';
 import FeatureRenderer from './FeatureRendererType';
-import { ThemeOptions } from '@mui/material';
+import { SimpleFeature } from '../../util';
+import type { SimpleFeatureSerialized } from '../../util';
+import type { ThemeOptions } from '@mui/material';
 export default class CircularChordRendererType extends FeatureRenderer {
     supportsSVG: boolean;
     deserializeResultsInClient(res: {

package/pluggableElementTypes/renderers/CircularChordRendererType.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
-const util_1 = require("../../util");
 const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
 const RpcRenderedSvgGroup_1 = __importDefault(require("./RpcRenderedSvgGroup"));
+const util_1 = require("../../util");
 class CircularChordRendererType extends FeatureRendererType_1.default {
     constructor() {
         super(...arguments);
@@ -14,11 +14,7 @@ class CircularChordRendererType extends FeatureRendererType_1.default {
     }
     deserializeResultsInClient(res, args) {
         const deserializedFeatures = new Map(res.features.map(f => util_1.SimpleFeature.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,
                 features: deserializedFeatures,
@@ -28,7 +24,6 @@ class CircularChordRendererType extends FeatureRendererType_1.default {
                     : '<text y="12" fill="black">SVG export not supported for this track</text>',
             };
         }
-        // hydrate res using ServerSideRenderedContent
         return {
             ...res,
             features: deserializedFeatures,

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.d.ts

@@ -1,8 +1,9 @@
-import { Feature } from '../../util/simpleFeature';
-import { Region } from '../../util/types';
-import ServerSideRenderer, { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, ResultsSerialized as ServerSideResultsSerialized, ResultsDeserialized as ServerSideResultsDeserialized } from './ServerSideRendererType';
-import RpcManager from '../../rpc/RpcManager';
-import { AnyConfigurationModel } from '../../configuration';
+import ServerSideRenderer from './ServerSideRendererType';
+import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType';
+import type { AnyConfigurationModel } from '../../configuration';
+import type RpcManager from '../../rpc/RpcManager';
+import type { Feature } from '../../util/simpleFeature';
+import type { Region } from '../../util/types';
 export interface RenderArgs extends ServerSideRenderArgs {
     blockKey: string;
 }
@@ -23,26 +24,10 @@ export interface ResultsSerializedSvgExport extends ResultsSerialized {
     reactElement: unknown;
 }
 export default class ComparativeServerSideRenderer extends ServerSideRenderer {
-    /**
-     * directly modifies the render arguments to prepare them to be serialized
-     * and sent to the worker.
-     *
-     * @param args - the arguments passed to render
-     * @returns the same object
-     */
     renameRegionsIfNeeded(args: RenderArgs): Promise<RenderArgs>;
     serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
     deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    /**
-     * Render method called on the client. Serializes args, then
-     * calls `render` with the RPC manager.
-     */
     renderInClient(rpcManager: RpcManager, args: RenderArgs): Promise<ServerSideResultsSerialized>;
-    /**
-     * @param renderArgs -
-     * @param feature -
-     * @returns true if this feature passes all configured filters
-     */
     featurePassesFilters(renderArgs: RenderArgsDeserialized, feature: Feature): boolean;
     getFeatures(renderArgs: {
         regions: Region[];

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.js

@@ -3,22 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererType"));
 const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
 const util_1 = require("../../util");
-const rxjs_1 = require("rxjs");
 function isSvgExport(e) {
     return 'canvasRecordedData' in e;
 }
 class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
-    /**
-     * directly modifies the render arguments to prepare them to be serialized
-     * and sent to the worker.
-     *
-     * @param args - the arguments passed to render
-     * @returns the same object
-     */
     async renameRegionsIfNeeded(args) {
         return args;
     }
@@ -29,7 +22,6 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
         };
         return super.serializeArgsInClient(deserializedArgs);
     }
-    // deserialize some of the results that came back from the worker
     deserializeResultsInClient(result, args) {
         const deserialized = super.deserializeResultsInClient(result, args);
         return {
@@ -37,10 +29,6 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
             blockKey: args.blockKey,
         };
     }
-    /**
-     * Render method called on the client. Serializes args, then
-     * calls `render` with the RPC manager.
-     */
     async renderInClient(rpcManager, args) {
         const results = (await rpcManager.call(args.sessionId, 'ComparativeRender', args));
         if (isSvgExport(results)) {
@@ -49,11 +37,6 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
         }
         return results;
     }
-    /**
-     * @param renderArgs -
-     * @param feature -
-     * @returns true if this feature passes all configured filters
-     */
     featurePassesFilters(renderArgs, feature) {
         return renderArgs.filters
             ? renderArgs.filters.passes(feature, renderArgs)
@@ -64,8 +47,6 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
         const { regions, sessionId, adapterConfig } = renderArgs;
         const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
         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);
@@ -75,13 +56,9 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
             }
             return requestRegion;
         });
-        // note that getFeaturesInMultipleRegions does not do glyph expansion
         const res = await (0, rxjs_1.firstValueFrom)(dataAdapter
             .getFeaturesInMultipleRegions(requestRegions, renderArgs)
-            .pipe(
-        // @ts-expect-error
-        (0, operators_1.filter)(f => this.featurePassesFilters(renderArgs, f)), (0, operators_1.toArray)()));
-        // dedupe needed xref https://github.com/GMOD/jbrowse-components/pull/3404/
+            .pipe((0, operators_1.filter)(f => this.featurePassesFilters(renderArgs, f)), (0, operators_1.toArray)()));
         return (0, util_1.dedupe)(res, f => f.id());
     }
 }

package/pluggableElementTypes/renderers/FeatureRendererType.d.ts

@@ -1,7 +1,8 @@
-import { Feature, SimpleFeatureSerialized } from '../../util/simpleFeature';
-import { AugmentedRegion as Region } from '../../util/types';
-import ServerSideRendererType, { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderResults as ServerSideRenderResults, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType';
-import { AnyConfigurationModel } from '../../configuration';
+import ServerSideRendererType from './ServerSideRendererType';
+import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults as ServerSideRenderResults, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType';
+import type { AnyConfigurationModel } from '../../configuration';
+import type { Feature, SimpleFeatureSerialized } from '../../util/simpleFeature';
+import type { AugmentedRegion as Region } from '../../util/types';
 export interface RenderArgs extends ServerSideRenderArgs {
     displayModel?: {
         id: string;
@@ -38,55 +39,12 @@ export interface ResultsDeserialized extends ServerSideResultsDeserialized {
     blockKey: string;
 }
 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.
-     *
-     * @param args - the arguments passed to render
-     */
     serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
-    /**
-     * Adds feature deserialization to base server-side result deserialization
-     *
-     * @param results - the results of the render
-     * @param args - the arguments passed to render
-     */
     deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    /**
-     * Adds feature serialization to base server-side result serialization
-     *
-     * @param result - object containing the results of calling the `render`
-     * method
-     * @param args - deserialized render args
-     */
     serializeResultsInWorker(result: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
-    /**
-     * will expand if soft clipping or feature glyphs are shown
-     *
-     * @param region - rendering region
-     * @param _renderArgs - render args, unused, may be used in deriving classes
-     */
     getExpandedRegion(region: Region, _renderArgs: RenderArgsDeserialized): Region;
-    /**
-     * use the dataAdapter to fetch the features to be rendered
-     *
-     * @param renderArgs -
-     * @returns Map of features as `{ id => feature, ... }`
-     */
     getFeatures(renderArgs: RenderArgsDeserialized): Promise<Map<string, Feature>>;
-    /**
-     * @param renderArgs -
-     * @param feature -
-     * @returns true if this feature passes all configured filters
-     */
     featurePassesFilters(renderArgs: RenderArgsDeserialized, feature: Feature): boolean;
-    /**
-     * gets features and renders
-     *
-     * @param props - render args
-     */
     render(props: RenderArgsDeserialized & {
         features?: Map<string, Feature>;
     }): Promise<RenderResults>;

package/pluggableElementTypes/renderers/FeatureRendererType.js

@@ -3,39 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const operators_1 = require("rxjs/operators");
-const clone_1 = __importDefault(require("clone"));
 const rxjs_1 = require("rxjs");
-// locals
-const util_1 = require("../../util");
-const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
-const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const operators_1 = require("rxjs/operators");
 const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererType"));
 const BaseAdapter_1 = require("../../data_adapters/BaseAdapter");
+const dataAdapterCache_1 = require("../../data_adapters/dataAdapterCache");
+const util_1 = require("../../util");
+const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
+const stopToken_1 = require("../../util/stopToken");
 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.
-     *
-     * @param args - the arguments passed to render
-     */
     serializeArgsInClient(args) {
-        const { regions } = args;
-        const serializedArgs = {
+        return super.serializeArgsInClient({
             ...args,
             displayModel: undefined,
-            regions: (0, clone_1.default)(regions),
-        };
-        return super.serializeArgsInClient(serializedArgs);
+            regions: structuredClone(args.regions),
+        });
     }
-    /**
-     * Adds feature deserialization to base server-side result deserialization
-     *
-     * @param results - the results of the render
-     * @param args - the arguments passed to render
-     */
     deserializeResultsInClient(result, args) {
         const deserializedFeatures = new Map(result.features.map(f => simpleFeature_1.default.fromJSON(f)).map(f => [f.id(), f]));
         const deserialized = super.deserializeResultsInClient({
@@ -48,13 +31,6 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
             features: deserializedFeatures,
         };
     }
-    /**
-     * Adds feature serialization to base server-side result serialization
-     *
-     * @param result - object containing the results of calling the `render`
-     * method
-     * @param args - deserialized render args
-     */
     serializeResultsInWorker(result, args) {
         const serialized = super.serializeResultsInWorker(result, args);
         const { features } = result;
@@ -63,65 +39,36 @@ class FeatureRendererType extends ServerSideRendererType_1.default {
             features: (0, util_1.iterMap)(features.values(), f => f.toJSON(), features.size),
         };
     }
-    /**
-     * will expand if soft clipping or feature glyphs are shown
-     *
-     * @param region - rendering region
-     * @param _renderArgs - render args, unused, may be used in deriving classes
-     */
     getExpandedRegion(region, _renderArgs) {
         return region;
     }
-    /**
-     * use the dataAdapter to fetch the features to be rendered
-     *
-     * @param renderArgs -
-     * @returns Map of features as `{ id => feature, ... }`
-     */
     async getFeatures(renderArgs) {
         const pm = this.pluginManager;
-        const { signal, regions, sessionId, adapterConfig } = renderArgs;
+        const { stopToken, regions, sessionId, adapterConfig } = renderArgs;
         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');
         }
-        // make sure the requested region's start and end are integers, if
-        // there is a region specification.
-        const requestRegions = regions.map(r => {
-            const requestRegion = { ...r };
-            if (requestRegion.start) {
-                requestRegion.start = Math.floor(requestRegion.start);
-            }
-            if (requestRegion.end) {
-                requestRegion.end = Math.ceil(requestRegion.end);
-            }
-            return requestRegion;
-        });
+        const requestRegions = regions.map(r => ({
+            ...r,
+            start: Math.floor(r.start),
+            end: Math.ceil(r.end),
+        }));
         const region = requestRegions[0];
         const featureObservable = requestRegions.length === 1
             ? dataAdapter.getFeatures(this.getExpandedRegion(region, renderArgs), renderArgs)
             : dataAdapter.getFeaturesInMultipleRegions(requestRegions, renderArgs);
         const feats = await (0, rxjs_1.firstValueFrom)(featureObservable.pipe((0, operators_1.toArray)()));
-        (0, util_1.checkAbortSignal)(signal);
+        (0, stopToken_1.checkStopToken)(stopToken);
         return new Map(feats
             .filter(feat => this.featurePassesFilters(renderArgs, feat))
             .map(feat => [feat.id(), feat]));
     }
-    /**
-     * @param renderArgs -
-     * @param feature -
-     * @returns true if this feature passes all configured filters
-     */
     featurePassesFilters(renderArgs, feature) {
         return renderArgs.filters
             ? renderArgs.filters.passes(feature, renderArgs)
             : true;
     }
-    /**
-     * gets features and renders
-     *
-     * @param props - render args
-     */
     async render(props) {
         const features = props.features || (await this.getFeatures(props));
         const result = await super.render({ ...props, features });

package/pluggableElementTypes/renderers/RendererType.d.ts

@@ -1,8 +1,8 @@
-import { ReactElement } from 'react';
+import type { ReactElement } from 'react';
 import PluggableElementBase from '../PluggableElementBase';
-import { AnyConfigurationSchemaType } from '../../configuration';
-import { AnyReactComponentType } from '../../util';
-import PluginManager from '../../PluginManager';
+import type PluginManager from '../../PluginManager';
+import type { AnyConfigurationSchemaType } from '../../configuration';
+import type { AnyReactComponentType } from '../../util';
 export type RenderProps = Record<string, unknown>;
 export interface RenderResults {
     reactElement?: ReactElement;
@@ -21,9 +21,5 @@ export default class RendererType extends PluggableElementBase {
         pluginManager: PluginManager;
     });
     render(props: RenderProps): Promise<RenderResults>;
-    /**
-     * frees resources associated with the given range, session, etc.
-     * optionally returns the number of data items deleted
-     */
     freeResources(): number;
 }

package/pluggableElementTypes/renderers/RendererType.js

@@ -18,11 +18,7 @@ class RendererType extends PluggableElementBase_1.default {
             reactElement: react_1.default.createElement(this.ReactComponent, props, null),
         };
     }
-    /**
-     * frees resources associated with the given range, session, etc.
-     * optionally returns the number of data items deleted
-     */
-    freeResources( /* specification: {} */) {
+    freeResources() {
         return 0;
     }
 }

package/pluggableElementTypes/renderers/RpcRenderedSvgGroup.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { AnyReactComponentType, Feature } from '../../util';
-import { ThemeOptions } from '@mui/material';
+import type { AnyReactComponentType, Feature } from '../../util';
+import type { ThemeOptions } from '@mui/material';
 interface Props {
     html: string;
     features: Map<string, Feature>;