@jbrowse/core 2.3.4 → 2.4.1

package/pluggableElementTypes/RpcMethodType.js

@@ -3,16 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const map_obj_1 = __importDefault(require("../util/map-obj"));
 const PluggableElementBase_1 = __importDefault(require("./PluggableElementBase"));
 const tracks_1 = require("../util/tracks");
-const mobx_state_tree_1 = require("mobx-state-tree");
 const types_1 = require("../util/types");
 const remoteAbortSignals_1 = require("../rpc/remoteAbortSignals");
 class RpcMethodType extends PluggableElementBase_1.default {
     constructor(pluginManager) {
-        super({ name: '' });
+        super({});
         this.pluginManager = pluginManager;
-        this.name = 'UNKNOWN';
     }
     async serializeArguments(args, _rpcDriverClassName) {
         const blobMap = (0, tracks_1.getBlobMap)();
@@ -25,7 +24,7 @@ class RpcMethodType extends PluggableElementBase_1.default {
         if (!(0, types_1.isAppRootModel)(rootModel) || loc.internetAccountPreAuthorization) {
             return loc;
         }
-        const account = rootModel === null || rootModel === void 0 ? void 0 : rootModel.findAppropriateInternetAccount(loc);
+        const account = rootModel.findAppropriateInternetAccount(loc);
         if (account) {
             loc.internetAccountPreAuthorization =
                 await account.getPreAuthorizationInformation(loc);
@@ -37,55 +36,45 @@ class RpcMethodType extends PluggableElementBase_1.default {
             (0, tracks_1.setBlobMap)(serializedArgs.blobMap);
         }
         const { signal } = serializedArgs;
-        if (signal && (0, remoteAbortSignals_1.isRemoteAbortSignal)(signal)) {
-            return { ...serializedArgs, signal: (0, remoteAbortSignals_1.deserializeAbortSignal)(signal) };
-        }
-        return { ...serializedArgs, signal: undefined };
+        return {
+            ...serializedArgs,
+            signal: (0, remoteAbortSignals_1.isRemoteAbortSignal)(signal)
+                ? (0, remoteAbortSignals_1.deserializeAbortSignal)(signal)
+                : undefined,
+        };
     }
     async serializeReturn(originalReturn, _args, _rpcDriverClassName) {
         return originalReturn;
     }
-    async deserializeReturn(serializedReturn, _args, _rpcDriverClassName) {
+    async deserializeReturn(serializedReturn, _args, _rpcDriver) {
+        var _a;
         let r;
-        const { rootModel } = this.pluginManager;
         try {
             r = await serializedReturn;
         }
         catch (error) {
             if ((0, types_1.isAuthNeededException)(error)) {
-                // @ts-ignore
-                const retryAccount = rootModel === null || rootModel === void 0 ? void 0 : rootModel.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
+                const retryAccount = 
+                // @ts-expect-error
+                (_a = this.pluginManager.rootModel) === null || _a === void 0 ? void 0 : _a.createEphemeralInternetAccount(`HTTPBasicInternetAccount-${new URL(error.url).origin}`, {}, error.url);
                 throw new types_1.RetryError('Retrying with created internet account', retryAccount.internetAccountId);
             }
             throw error;
         }
         return r;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async augmentLocationObjects(thing) {
-        if ((0, mobx_state_tree_1.isStateTreeNode)(thing) && !(0, mobx_state_tree_1.isAlive)(thing)) {
-            return thing;
-        }
-        if ((0, types_1.isUriLocation)(thing)) {
-            await this.serializeNewAuthArguments(thing);
-        }
-        if (Array.isArray(thing)) {
-            for (const val of thing) {
-                await this.augmentLocationObjects(val);
-            }
-        }
-        if (typeof thing === 'object' && thing !== null) {
-            for (const value of Object.values(thing)) {
-                if (Array.isArray(value)) {
-                    for (const val of value) {
-                        await this.augmentLocationObjects(val);
-                    }
-                }
-                else if (typeof value === 'object' && value !== null) {
-                    await this.augmentLocationObjects(value);
-                }
+        const uris = [];
+        // using map-obj avoids cycles, seen in circular view svg export
+        (0, map_obj_1.default)(thing, val => {
+            if ((0, types_1.isUriLocation)(val)) {
+                uris.push(val);
             }
+        });
+        for (const uri of uris) {
+            await this.serializeNewAuthArguments(uri);
         }
+        return thing;
     }
 }
 exports.default = RpcMethodType;

package/pluggableElementTypes/index.d.ts

@@ -11,6 +11,16 @@ import TextSearchAdapterType from './TextSearchAdapterType';
 import AddTrackWorkflowType from './AddTrackWorkflowType';
 export * from './renderers';
 export * from './models';
-export { AdapterType, ConnectionType, RendererType, WidgetType, TrackType, DisplayType, ViewType, RpcMethodType, InternetAccountType, TextSearchAdapterType, AddTrackWorkflowType, };
 export type PluggableElementType = AdapterType | ConnectionType | RendererType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;
 export type PluggableElementMember = keyof AdapterType | keyof ConnectionType | keyof RendererType | keyof WidgetType | keyof TrackType | keyof DisplayType | keyof ViewType | keyof RpcMethodType | keyof InternetAccountType | keyof TextSearchAdapterType | keyof AddTrackWorkflowType;
+export { default as AdapterType } from './AdapterType';
+export { default as RendererType } from './renderers/RendererType';
+export { default as ConnectionType } from './ConnectionType';
+export { default as TrackType } from './TrackType';
+export { default as WidgetType } from './WidgetType';
+export { default as ViewType } from './ViewType';
+export { default as DisplayType } from './DisplayType';
+export { default as InternetAccountType } from './InternetAccountType';
+export { default as RpcMethodType } from './RpcMethodType';
+export { default as AddTrackWorkflowType } from './AddTrackWorkflowType';
+export { default as TextSearchAdapterType } from './TextSearchAdapterType';

package/pluggableElementTypes/index.js

@@ -17,28 +17,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddTrackWorkflowType = exports.TextSearchAdapterType = exports.InternetAccountType = exports.RpcMethodType = exports.ViewType = exports.DisplayType = exports.TrackType = exports.WidgetType = exports.RendererType = exports.ConnectionType = exports.AdapterType = void 0;
-const AdapterType_1 = __importDefault(require("./AdapterType"));
-exports.AdapterType = AdapterType_1.default;
-const ConnectionType_1 = __importDefault(require("./ConnectionType"));
-exports.ConnectionType = ConnectionType_1.default;
-const RendererType_1 = __importDefault(require("./renderers/RendererType"));
-exports.RendererType = RendererType_1.default;
-const WidgetType_1 = __importDefault(require("./WidgetType"));
-exports.WidgetType = WidgetType_1.default;
-const TrackType_1 = __importDefault(require("./TrackType"));
-exports.TrackType = TrackType_1.default;
-const DisplayType_1 = __importDefault(require("./DisplayType"));
-exports.DisplayType = DisplayType_1.default;
-const ViewType_1 = __importDefault(require("./ViewType"));
-exports.ViewType = ViewType_1.default;
-const RpcMethodType_1 = __importDefault(require("./RpcMethodType"));
-exports.RpcMethodType = RpcMethodType_1.default;
-const InternetAccountType_1 = __importDefault(require("./InternetAccountType"));
-exports.InternetAccountType = InternetAccountType_1.default;
-const TextSearchAdapterType_1 = __importDefault(require("./TextSearchAdapterType"));
-exports.TextSearchAdapterType = TextSearchAdapterType_1.default;
-const AddTrackWorkflowType_1 = __importDefault(require("./AddTrackWorkflowType"));
-exports.AddTrackWorkflowType = AddTrackWorkflowType_1.default;
+exports.TextSearchAdapterType = exports.AddTrackWorkflowType = exports.RpcMethodType = exports.InternetAccountType = exports.DisplayType = exports.ViewType = exports.WidgetType = exports.TrackType = exports.ConnectionType = exports.RendererType = exports.AdapterType = void 0;
 __exportStar(require("./renderers"), exports);
 __exportStar(require("./models"), exports);
+var AdapterType_1 = require("./AdapterType");
+Object.defineProperty(exports, "AdapterType", { enumerable: true, get: function () { return __importDefault(AdapterType_1).default; } });
+var RendererType_1 = require("./renderers/RendererType");
+Object.defineProperty(exports, "RendererType", { enumerable: true, get: function () { return __importDefault(RendererType_1).default; } });
+var ConnectionType_1 = require("./ConnectionType");
+Object.defineProperty(exports, "ConnectionType", { enumerable: true, get: function () { return __importDefault(ConnectionType_1).default; } });
+var TrackType_1 = require("./TrackType");
+Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return __importDefault(TrackType_1).default; } });
+var WidgetType_1 = require("./WidgetType");
+Object.defineProperty(exports, "WidgetType", { enumerable: true, get: function () { return __importDefault(WidgetType_1).default; } });
+var ViewType_1 = require("./ViewType");
+Object.defineProperty(exports, "ViewType", { enumerable: true, get: function () { return __importDefault(ViewType_1).default; } });
+var DisplayType_1 = require("./DisplayType");
+Object.defineProperty(exports, "DisplayType", { enumerable: true, get: function () { return __importDefault(DisplayType_1).default; } });
+var InternetAccountType_1 = require("./InternetAccountType");
+Object.defineProperty(exports, "InternetAccountType", { enumerable: true, get: function () { return __importDefault(InternetAccountType_1).default; } });
+var RpcMethodType_1 = require("./RpcMethodType");
+Object.defineProperty(exports, "RpcMethodType", { enumerable: true, get: function () { return __importDefault(RpcMethodType_1).default; } });
+var AddTrackWorkflowType_1 = require("./AddTrackWorkflowType");
+Object.defineProperty(exports, "AddTrackWorkflowType", { enumerable: true, get: function () { return __importDefault(AddTrackWorkflowType_1).default; } });
+var TextSearchAdapterType_1 = require("./TextSearchAdapterType");
+Object.defineProperty(exports, "TextSearchAdapterType", { enumerable: true, get: function () { return __importDefault(TextSearchAdapterType_1).default; } });

package/pluggableElementTypes/models/BaseConnectionModelFactory.js

@@ -18,8 +18,8 @@ function stateModelFactory(pluginManager) {
     })
         .actions(self => ({
         afterAttach() {
-            if (!self.tracks.length) {
-                // @ts-ignore
+            if (self.tracks.length === 0) {
+                // @ts-expect-error
                 self.connect(self.configuration);
             }
         },

package/pluggableElementTypes/models/BaseTrackModel.js

@@ -12,9 +12,9 @@ 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 compatTypes = new Set(viewType.displayTypes.map(d => d.name));
     const displays = self.configuration.displays;
-    return displays.filter(d => compatTypes.includes(d.type));
+    return displays.filter(d => compatTypes.has(d.type));
 }
 exports.getCompatibleDisplays = getCompatibleDisplays;
 /**
@@ -85,20 +85,17 @@ function createBaseTrackModel(pm, trackType, baseTrackConfig) {
          * #getter
          */
         get viewMenuActions() {
-            return self.displays.map(d => d.viewMenuActions).flat();
+            return self.displays.flatMap(d => d.viewMenuActions);
         },
         /**
          * #getter
          */
         get canConfigure() {
             const session = (0, util_1.getSession)(self);
+            const { sessionTracks, adminMode } = session;
             return ((0, types_1.isSessionModelWithConfigEditing)(session) &&
-                // @ts-ignore
-                (session.adminMode ||
-                    // @ts-ignore
-                    session.sessionTracks.find(track => {
-                        return track.trackId === self.configuration.trackId;
-                    })));
+                (adminMode ||
+                    sessionTracks.find((track) => track.trackId === self.configuration.trackId)));
         },
     }))
         .actions(self => ({
@@ -115,7 +112,7 @@ function createBaseTrackModel(pm, trackType, baseTrackConfig) {
             const session = (0, util_1.getSession)(self);
             const view = (0, util_1.getContainingView)(self);
             if ((0, types_1.isSessionModelWithConfigEditing)(session)) {
-                // @ts-ignore
+                // @ts-expect-error
                 const trackConf = session.editTrackConfiguration(self.configuration);
                 if (trackConf && trackConf !== self.configuration) {
                     view.hideTrack(self.configuration);
@@ -176,9 +173,7 @@ function createBaseTrackModel(pm, trackType, baseTrackConfig) {
          * #method
          */
         trackMenuItems() {
-            const menuItems = self.displays
-                .map(d => d.trackMenuItems())
-                .flat();
+            const menuItems = self.displays.flatMap(d => d.trackMenuItems());
             const shownId = self.displays[0].configuration.displayId;
             const compatDisp = getCompatibleDisplays(self);
             return [

package/pluggableElementTypes/renderers/CircularChordRendererType.d.ts

@@ -1,6 +1,8 @@
-import { SimpleFeatureSerialized } from '../../util/simpleFeature';
+/// <reference types="react" />
+import { SimpleFeature, SimpleFeatureSerialized } from '../../util';
 import FeatureRenderer from './FeatureRendererType';
 export default class CircularChordRendererType extends FeatureRenderer {
+    supportsSVG: boolean;
     deserializeResultsInClient(res: {
         features: SimpleFeatureSerialized[];
         html: string;
@@ -8,5 +10,14 @@ export default class CircularChordRendererType extends FeatureRenderer {
         exportSVG?: {
             rasterizeLayers?: boolean;
         };
-    }): any;
+    }): {
+        features: Map<string, SimpleFeature>;
+        blockKey: string;
+        html: string;
+    } | {
+        features: Map<string, SimpleFeature>;
+        blockKey: string;
+        reactElement: JSX.Element;
+        html: string;
+    };
 }

package/pluggableElementTypes/renderers/CircularChordRendererType.js

@@ -4,12 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
-const simpleFeature_1 = __importDefault(require("../../util/simpleFeature"));
+const util_1 = require("../../util");
 const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
 const RpcRenderedSvgGroup_1 = __importDefault(require("./RpcRenderedSvgGroup"));
 class CircularChordRendererType extends FeatureRendererType_1.default {
+    constructor() {
+        super(...arguments);
+        this.supportsSVG = true;
+    }
     deserializeResultsInClient(res, args) {
-        const deserializedFeatures = new Map(res.features.map(f => simpleFeature_1.default.fromJSON(f)).map(f => [f.id(), f]));
+        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
@@ -17,6 +21,8 @@ class CircularChordRendererType extends FeatureRendererType_1.default {
             // document
             return {
                 ...res,
+                features: deserializedFeatures,
+                blockKey: 'circularChord',
                 html: this.supportsSVG
                     ? res.html
                     : '<text y="12" fill="black">SVG export not supported for this track</text>',
@@ -25,6 +31,8 @@ class CircularChordRendererType extends FeatureRendererType_1.default {
         // hydrate res using ServerSideRenderedContent
         return {
             ...res,
+            features: deserializedFeatures,
+            blockKey: 'circularChord',
             reactElement: (react_1.default.createElement(RpcRenderedSvgGroup_1.default, { ...args, ...res, features: deserializedFeatures, RenderingComponent: this.ReactComponent })),
         };
     }

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.d.ts

@@ -1,5 +1,5 @@
 import { Feature } from '../../util/simpleFeature';
-import ServerSideRenderer, { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderResults, ResultsSerialized as ServerSideResultsSerialized, ResultsDeserialized as ServerSideResultsDeserialized } from './ServerSideRendererType';
+import ServerSideRenderer, { RenderArgs as ServerSideRenderArgs, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, ResultsSerialized as ServerSideResultsSerialized, ResultsDeserialized as ServerSideResultsDeserialized } from './ServerSideRendererType';
 import RpcManager from '../../rpc/RpcManager';
 export interface RenderArgs extends ServerSideRenderArgs {
     displayModel: {};
@@ -13,11 +13,16 @@ export interface RenderArgsDeserialized extends ServerSideRenderArgsDeserialized
     displayModel: {};
     blockKey: string;
 }
-export type { RenderResults };
 export type ResultsSerialized = ServerSideResultsSerialized;
 export interface ResultsDeserialized extends ServerSideResultsDeserialized {
     blockKey: string;
 }
+export interface ResultsSerializedSvgExport extends ResultsSerialized {
+    canvasRecordedData: unknown;
+    width: number;
+    height: number;
+    reactElement: unknown;
+}
 export default class ComparativeServerSideRenderer extends ServerSideRenderer {
     /**
      * directly modifies the render arguments to prepare
@@ -48,3 +53,4 @@ export default class ComparativeServerSideRenderer extends ServerSideRenderer {
     featurePassesFilters(renderArgs: RenderArgsDeserialized, feature: Feature): boolean;
     getFeatures(renderArgs: any): Promise<Feature[]>;
 }
+export { type RenderResults } from './ServerSideRendererType';

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.js

@@ -9,6 +9,9 @@ const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererTy
 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
@@ -43,7 +46,12 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
      * calls `render` with the RPC manager.
      */
     async renderInClient(rpcManager, args) {
-        return rpcManager.call(args.sessionId, 'ComparativeRender', args);
+        const results = (await rpcManager.call(args.sessionId, 'ComparativeRender', args));
+        if (isSvgExport(results)) {
+            results.html = await (0, util_1.getSerializedSvg)(results);
+            delete results.reactElement;
+        }
+        return results;
     }
     /**
      * @param renderArgs -
@@ -59,9 +67,7 @@ class ComparativeServerSideRenderer extends ServerSideRendererType_1.default {
         const pm = this.pluginManager;
         const { sessionId, adapterConfig } = renderArgs;
         const { dataAdapter } = await (0, dataAdapterCache_1.getAdapter)(pm, sessionId, adapterConfig);
-        let regions = [];
-        // @ts-ignore this is instantiated by the getFeatures call
-        regions = renderArgs.regions;
+        const regions = renderArgs.regions;
         if (!regions || regions.length === 0) {
             console.warn('no regions supplied to comparative renderer');
             return [];

package/pluggableElementTypes/renderers/ServerSideRendererType.d.ts

@@ -25,7 +25,6 @@ export interface RenderArgsDeserialized extends BaseRenderArgs {
     config: AnyConfigurationModel;
     filters: SerializableFilterChain;
 }
-export type { RenderResults };
 export interface ResultsSerialized extends Omit<RenderResults, 'reactElement'> {
     html: string;
 }
@@ -87,3 +86,4 @@ export default class ServerSideRenderer extends RendererType {
     renderInWorker(args: RenderArgsSerialized): Promise<ResultsSerialized>;
     freeResourcesInClient(rpcManager: RpcManager, args: RenderArgs): Promise<number>;
 }
+export { type RenderResults } from './RendererType';

package/pluggableElementTypes/renderers/ServerSideRendererType.js

@@ -1,34 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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 styles_1 = require("@mui/material/styles");
-const canvas_sequencer_1 = require("canvas-sequencer");
 const server_1 = require("react-dom/server");
 const mobx_state_tree_1 = require("mobx-state-tree");
 // locals
@@ -79,7 +55,7 @@ class ServerSideRenderer extends RendererType_1.default {
                     : '<text y="12" fill="black">SVG export not supported for this track</text>',
             };
         }
-        // hydrate res using ServerSideRenderedContent
+        // get res using ServerSideRenderedContent
         return {
             ...res,
             reactElement: (react_1.default.createElement(ServerSideRenderedContent_1.default, { ...args, ...res, RenderingComponent: this.ReactComponent })),
@@ -124,15 +100,7 @@ class ServerSideRenderer extends RendererType_1.default {
     async renderInClient(rpcManager, args) {
         const results = (await rpcManager.call(args.sessionId, 'CoreRender', args));
         if (isSvgExport(results)) {
-            const { width, height, canvasRecordedData } = results;
-            const C2S = await Promise.resolve().then(() => __importStar(require('canvas2svg')));
-            const ctx = new C2S.default(width, height);
-            const seq = new canvas_sequencer_1.CanvasSequence(canvasRecordedData);
-            seq.execute(ctx);
-            const str = ctx.getSvg();
-            // innerHTML strips the outer <svg> element from returned data, we add
-            // our own <svg> element in the view's SVG export
-            results.html = str.innerHTML;
+            results.html = await (0, util_1.getSerializedSvg)(results);
             delete results.reactElement;
         }
         return results;

package/pluggableElementTypes/renderers/index.d.ts

@@ -1,9 +1,7 @@
-import BoxRendererType from './BoxRendererType';
-import CircularChordRendererType from './CircularChordRendererType';
-import ComparativeServerSideRendererType from './ComparativeServerSideRendererType';
-import FeatureRendererType from './FeatureRendererType';
-import RendererType, { RenderProps } from './RendererType';
-import ServerSideRenderedContent from './ServerSideRenderedContent';
-import ServerSideRendererType from './ServerSideRendererType';
-export { BoxRendererType, CircularChordRendererType, ComparativeServerSideRendererType, FeatureRendererType, RendererType, ServerSideRenderedContent, ServerSideRendererType, };
-export type { RenderProps };
+export { default as BoxRendererType } from './BoxRendererType';
+export { default as ComparativeServerSideRendererType } from './ComparativeServerSideRendererType';
+export { default as CircularChordRendererType } from './CircularChordRendererType';
+export { default as RendererType, type RenderProps } from './RendererType';
+export { default as FeatureRendererType } from './FeatureRendererType';
+export { default as ServerSideRenderedContent } from './ServerSideRenderedContent';
+export { default as ServerSideRendererType } from './ServerSideRendererType';

package/pluggableElementTypes/renderers/index.js

@@ -3,18 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerSideRendererType = exports.ServerSideRenderedContent = exports.RendererType = exports.FeatureRendererType = exports.ComparativeServerSideRendererType = exports.CircularChordRendererType = exports.BoxRendererType = void 0;
-const BoxRendererType_1 = __importDefault(require("./BoxRendererType"));
-exports.BoxRendererType = BoxRendererType_1.default;
-const CircularChordRendererType_1 = __importDefault(require("./CircularChordRendererType"));
-exports.CircularChordRendererType = CircularChordRendererType_1.default;
-const ComparativeServerSideRendererType_1 = __importDefault(require("./ComparativeServerSideRendererType"));
-exports.ComparativeServerSideRendererType = ComparativeServerSideRendererType_1.default;
-const FeatureRendererType_1 = __importDefault(require("./FeatureRendererType"));
-exports.FeatureRendererType = FeatureRendererType_1.default;
-const RendererType_1 = __importDefault(require("./RendererType"));
-exports.RendererType = RendererType_1.default;
-const ServerSideRenderedContent_1 = __importDefault(require("./ServerSideRenderedContent"));
-exports.ServerSideRenderedContent = ServerSideRenderedContent_1.default;
-const ServerSideRendererType_1 = __importDefault(require("./ServerSideRendererType"));
-exports.ServerSideRendererType = ServerSideRendererType_1.default;
+exports.ServerSideRendererType = exports.ServerSideRenderedContent = exports.FeatureRendererType = exports.RendererType = exports.CircularChordRendererType = exports.ComparativeServerSideRendererType = exports.BoxRendererType = void 0;
+var BoxRendererType_1 = require("./BoxRendererType");
+Object.defineProperty(exports, "BoxRendererType", { enumerable: true, get: function () { return __importDefault(BoxRendererType_1).default; } });
+var ComparativeServerSideRendererType_1 = require("./ComparativeServerSideRendererType");
+Object.defineProperty(exports, "ComparativeServerSideRendererType", { enumerable: true, get: function () { return __importDefault(ComparativeServerSideRendererType_1).default; } });
+var CircularChordRendererType_1 = require("./CircularChordRendererType");
+Object.defineProperty(exports, "CircularChordRendererType", { enumerable: true, get: function () { return __importDefault(CircularChordRendererType_1).default; } });
+var RendererType_1 = require("./RendererType");
+Object.defineProperty(exports, "RendererType", { enumerable: true, get: function () { return __importDefault(RendererType_1).default; } });
+var FeatureRendererType_1 = require("./FeatureRendererType");
+Object.defineProperty(exports, "FeatureRendererType", { enumerable: true, get: function () { return __importDefault(FeatureRendererType_1).default; } });
+var ServerSideRenderedContent_1 = require("./ServerSideRenderedContent");
+Object.defineProperty(exports, "ServerSideRenderedContent", { enumerable: true, get: function () { return __importDefault(ServerSideRenderedContent_1).default; } });
+var ServerSideRendererType_1 = require("./ServerSideRendererType");
+Object.defineProperty(exports, "ServerSideRendererType", { enumerable: true, get: function () { return __importDefault(ServerSideRendererType_1).default; } });

package/pluggableElementTypes/renderers/util/serializableFilterChain.js

@@ -15,7 +15,7 @@ class SerializableFilterChain {
     passes(...args) {
         for (let i = 0; i < this.filterChain.length; i += 1) {
             if (
-            // @ts-ignore
+            // @ts-expect-error
             !this.filterChain[i].expr.evalSync({ feature: args[0] })) {
                 return false;
             }

package/rpc/BaseRpcDriver.js

@@ -76,7 +76,7 @@ class BaseRpcDriver {
     filterArgs(thing, sessionId) {
         if (Array.isArray(thing)) {
             return thing
-                .filter(isClonable)
+                .filter(thing => isClonable(thing))
                 .map(t => this.filterArgs(t, sessionId));
         }
         if (typeof thing === 'object' && thing !== null) {
@@ -106,7 +106,11 @@ class BaseRpcDriver {
         const hardwareConcurrency = detectHardwareConcurrency();
         const workerCount = (0, configuration_1.readConfObject)(this.config, 'workerCount') ||
             (0, util_1.clamp)(1, Math.max(1, hardwareConcurrency - 1), 5);
-        return [...new Array(workerCount)].map(() => new LazyWorker(this));
+        const workers = [];
+        for (let i = 0; i < workerCount; i++) {
+            workers.push(new LazyWorker(this));
+        }
+        return workers;
     }
     getWorkerPool() {
         if (!this.workerPool) {
@@ -125,12 +129,7 @@ class BaseRpcDriver {
             this.lastWorkerAssignment = workerAssignment;
             workerNumber = workerAssignment;
         }
-        // console.log(`${sessionId} -> worker ${workerNumber}`)
-        const worker = workers[workerNumber].getWorker();
-        if (!worker) {
-            throw new Error('no web workers registered for RPC');
-        }
-        return worker;
+        return workers[workerNumber].getWorker();
     }
     async call(pluginManager, sessionId, functionName, args, options = {}) {
         if (!sessionId) {

package/rpc/WebWorkerRpcDriver.js

@@ -46,18 +46,24 @@ class WebWorkerRpcDriver extends BaseRpcDriver_1.default {
         // send the worker its boot configuration using info from the pluginManager
         return new Promise((resolve, reject) => {
             const listener = (e) => {
-                if (e.data.message === 'ready') {
-                    resolve(worker);
-                    worker.workers[0].removeEventListener('message', listener);
-                }
-                else if (e.data.message === 'readyForConfig') {
-                    worker.workers[0].postMessage({
-                        message: 'config',
-                        config: this.workerBootConfiguration,
-                    });
-                }
-                else if (e.data.message === 'error') {
-                    reject((0, serialize_error_1.deserializeError)(e.data.error));
+                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;
+                    }
+                    // No default
                 }
             };
             worker.workers[0].addEventListener('message', listener);

package/rpc/coreRpcMethods.d.ts

@@ -1,11 +1,9 @@
-import CoreGetRefNames from './methods/CoreGetRefNames';
-import CoreGetMetadata from './methods/CoreGetMetadata';
-import CoreGetFeatureDetails from './methods/CoreGetFeatureDetails';
-import CoreGetFeatures from './methods/CoreGetFeatures';
-import CoreGetFileInfo from './methods/CoreGetFileInfo';
-import CoreFreeResources from './methods/CoreFreeResources';
-import CoreRender from './methods/CoreRender';
-import CoreEstimateRegionStats from './methods/CoreEstimateRegionStats';
-import { RenderArgs } from './methods/util';
-export type { RenderArgs };
-export { CoreGetRefNames, CoreGetFileInfo, CoreGetMetadata, CoreGetFeatures, CoreRender, CoreGetFeatureDetails, CoreFreeResources, CoreEstimateRegionStats, };
+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 { type RenderArgs } from './methods/util';
+export { default as CoreEstimateRegionStats } from './methods/CoreEstimateRegionStats';