@jbrowse/core 3.6.5 → 4.0.0

package/esm/pluggableElementTypes/models/components/SaveTrackData.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import ContentCopyIcon from '@mui/icons-material/ContentCopy';
+import GetAppIcon from '@mui/icons-material/GetApp';
+import HelpOutlineIcon from '@mui/icons-material/HelpOutline';
+import { Button, DialogActions, DialogContent, DialogContentText, DialogTitle, FormControl, FormControlLabel, FormLabel, IconButton, Radio, RadioGroup, TextField, } from '@mui/material';
+import copy from 'copy-to-clipboard';
+import { saveAs } from 'file-saver-es';
+import { observer } from 'mobx-react';
+import { getConf } from "../../../configuration/index.js";
+import { Dialog, ErrorMessage } from "../../../ui/index.js";
+import { getContainingView, getEnv, getSession } from "../../../util/index.js";
+import { getRpcSessionId } from "../../../util/tracks.js";
+import { makeStyles } from "../../../util/tss-react/index.js";
+const useStyles = makeStyles()({
+    root: {
+        width: '80em',
+    },
+    textAreaFont: {
+        fontFamily: 'Courier New',
+        whiteSpace: 'pre',
+    },
+});
+async function fetchFeatures(track, regions) {
+    const session = getSession(track);
+    const { rpcManager } = session;
+    const adapterConfig = getConf(track, ['adapter']);
+    const sessionId = getRpcSessionId(track);
+    return rpcManager.call(sessionId, 'CoreGetFeatures', {
+        adapterConfig,
+        regions,
+        sessionId,
+    });
+}
+function roundRegions(regions) {
+    return regions.map(r => ({
+        ...r,
+        start: Math.floor(r.start),
+        end: Math.ceil(r.end),
+    }));
+}
+const SaveTrackDataDialog = observer(function SaveTrackDataDialog({ model, handleClose, }) {
+    const { classes } = useStyles();
+    const options = useMemo(() => model.saveTrackFileFormatOptions(), [model]);
+    const [error, setError] = useState();
+    const [type, setType] = useState(Object.keys(options)[0]);
+    const [str, setStr] = useState('');
+    const [usedAdapterExport, setUsedAdapterExport] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [helpDialogOpen, setHelpDialogOpen] = useState(false);
+    const [helpDialogContent, setHelpDialogContent] = useState('');
+    const [copied, setCopied] = useState(false);
+    const view = getContainingView(model);
+    const { visibleRegions, coarseVisibleLocStrings: regionStr } = view;
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            try {
+                setError(undefined);
+                setLoading(true);
+                const session = getSession(model);
+                if (!visibleRegions?.length || !type) {
+                    return;
+                }
+                const { pluginManager } = getEnv(model);
+                const adapterConfig = getConf(model, ['adapter']);
+                const adapterType = pluginManager.getAdapterType(adapterConfig.type);
+                const supportsExport = adapterType?.adapterCapabilities?.includes('exportData');
+                const regions = roundRegions(visibleRegions);
+                if (supportsExport) {
+                    const { rpcManager } = session;
+                    const sessionId = getRpcSessionId(model);
+                    const exportResult = (await rpcManager.call('getExportData', 'CoreGetExportData', {
+                        adapterConfig,
+                        regions,
+                        formatType: type,
+                        sessionId,
+                    }));
+                    if (cancelled) {
+                        return;
+                    }
+                    setUsedAdapterExport(true);
+                    setStr(exportResult ?? '');
+                }
+                else {
+                    const features = await fetchFeatures(model, regions);
+                    if (cancelled) {
+                        return;
+                    }
+                    const result = await options[type].callback({
+                        features,
+                        session,
+                        assemblyName: regions[0].assemblyName,
+                    });
+                    if (cancelled) {
+                        return;
+                    }
+                    setUsedAdapterExport(false);
+                    setStr(result ?? '');
+                }
+            }
+            catch (e) {
+                if (!cancelled) {
+                    setError(e);
+                    console.error(e);
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [type, visibleRegions, options, model]);
+    return (_jsxs(Dialog, { maxWidth: "xl", open: true, onClose: handleClose, title: "Save track data", children: [_jsxs(DialogContent, { className: classes.root, children: [error ? _jsx(ErrorMessage, { error: error }) : null, _jsx("div", { children: _jsx(TextField, { label: "Region", value: regionStr, slotProps: {
+                                input: {
+                                    readOnly: true,
+                                },
+                            } }) }), _jsxs(FormControl, { children: [_jsx(FormLabel, { children: ['File type', usedAdapterExport ? '(adapter export)' : '']
+                                    .filter(f => !!f)
+                                    .join(' ') }), _jsx(RadioGroup, { value: type, onChange: e => {
+                                    setType(e.target.value);
+                                }, children: Object.entries(options).map(([key, val]) => (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: '4px' }, children: [_jsx(FormControlLabel, { value: key, control: _jsx(Radio, {}), label: val.name }), val.helpText ? (_jsx(IconButton, { size: "small", onClick: () => {
+                                                setHelpDialogContent(val.helpText);
+                                                setHelpDialogOpen(true);
+                                            }, title: "Show help for this format", children: _jsx(HelpOutlineIcon, { fontSize: "small" }) })) : null] }, key))) })] }), _jsx(TextField, { variant: "outlined", multiline: true, minRows: 5, maxRows: 15, fullWidth: true, value: loading
+                            ? 'Loading...'
+                            : str.length > 500_000
+                                ? 'File greater than 500kb, too large to view here. Click "Download" to save results to file'
+                                : str, slotProps: {
+                            input: {
+                                readOnly: true,
+                                classes: {
+                                    input: classes.textAreaFont,
+                                },
+                            },
+                        } })] }), _jsxs(DialogActions, { children: [_jsx(Button, { disabled: loading || !!error, onClick: () => {
+                            copy(str);
+                            setCopied(true);
+                            setTimeout(() => {
+                                setCopied(false);
+                            }, 1000);
+                        }, startIcon: _jsx(ContentCopyIcon, {}), children: copied ? 'Copied!' : 'Copy to clipboard' }), _jsx(Button, { disabled: loading || !!error, onClick: () => {
+                            const ext = options[type].extension;
+                            const blob = new Blob([str], { type: 'text/plain;charset=utf-8' });
+                            saveAs(blob, `jbrowse_track_data.${ext}`, { autoBom: false });
+                        }, startIcon: _jsx(GetAppIcon, {}), children: "Download" }), _jsx(Button, { variant: "contained", type: "submit", onClick: () => {
+                            handleClose();
+                        }, children: "Close" })] }), _jsxs(Dialog, { open: helpDialogOpen, onClose: () => {
+                    setHelpDialogOpen(false);
+                }, children: [_jsx(DialogTitle, { children: "Format Information" }), _jsx(DialogContent, { children: _jsx(DialogContentText, { children: helpDialogContent }) }), _jsx(DialogActions, { children: _jsx(Button, { autoFocus: true, onClick: () => {
+                                setHelpDialogOpen(false);
+                            }, children: "Close" }) })] })] }));
+});
+export default SaveTrackDataDialog;

package/esm/pluggableElementTypes/models/index.d.ts

@@ -0,0 +1,14 @@
+export { default as baseConnectionConfig } from './baseConnectionConfig.ts';
+export { default as BaseConnectionModelFactory } from './BaseConnectionModelFactory.ts';
+export { default as BaseViewModel } from './BaseViewModel.ts';
+export type { IBaseViewModel } from './BaseViewModel.ts';
+export { BaseDisplay } from './BaseDisplayModel.tsx';
+export type { BaseDisplayModel, BaseDisplayStateModel, } from './BaseDisplayModel.tsx';
+export { InternetAccount } from './InternetAccountModel.ts';
+export type { BaseInternetAccountModel, BaseInternetAccountStateModel, } from './InternetAccountModel.ts';
+export { BaseInternetAccountConfig } from './baseInternetAccountConfig.ts';
+export { createBaseTrackModel } from './BaseTrackModel.ts';
+export type { BaseTrackModel, BaseTrackStateModel } from './BaseTrackModel.ts';
+export { createBaseTrackConfig } from './baseTrackConfig.ts';
+export type { BaseTrackConfig, BaseTrackConfigSchema as BaseTrackConfigModel, } from './baseTrackConfig.ts';
+export type { FileTypeExporter } from './saveTrackFileTypes/types.ts';

package/esm/pluggableElementTypes/models/index.js

@@ -0,0 +1,8 @@
+export { default as baseConnectionConfig } from "./baseConnectionConfig.js";
+export { default as BaseConnectionModelFactory } from "./BaseConnectionModelFactory.js";
+export { default as BaseViewModel } from "./BaseViewModel.js";
+export { BaseDisplay } from "./BaseDisplayModel.js";
+export { InternetAccount } from "./InternetAccountModel.js";
+export { BaseInternetAccountConfig } from "./baseInternetAccountConfig.js";
+export { createBaseTrackModel } from "./BaseTrackModel.js";
+export { createBaseTrackConfig } from "./baseTrackConfig.js";

package/esm/pluggableElementTypes/models/saveTrackFileTypes/bed.d.ts

@@ -0,0 +1,4 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function stringifyBED({ features }: {
+    features: Feature[];
+}): string;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/bed.js

@@ -0,0 +1,9 @@
+export function stringifyBED({ features }) {
+    const fields = ['refName', 'start', 'end', 'name', 'score', 'strand'];
+    return features
+        .map(feature => fields
+        .map(field => feature.get(field) ?? '.')
+        .join('\t')
+        .trim())
+        .join('\n');
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/fetchSequence.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractSessionModel, Region } from '../../../util/index.ts';
+export declare function fetchSequence({ session, region, }: {
+    session: AbstractSessionModel;
+    region: Region;
+}): Promise<string | undefined>;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/fetchSequence.js

@@ -0,0 +1,17 @@
+import { getConf } from "../../../configuration/index.js";
+export async function fetchSequence({ session, region, }) {
+    const { rpcManager, assemblyManager } = session;
+    const assembly = assemblyManager.get(region.assemblyName);
+    if (!assembly) {
+        throw new Error(`assembly ${region.assemblyName} not found`);
+    }
+    const sessionId = 'getSequence';
+    return rpcManager.call(sessionId, 'CoreGetSequence', {
+        adapterConfig: getConf(assembly, ['sequence', 'adapter']),
+        region: {
+            ...region,
+            refName: assembly.getCanonicalRefName(region.refName),
+        },
+        sessionId,
+    });
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractSessionModel, Feature } from '../../../util/index.ts';
+export declare function formatFeatWithSubfeatures(feature: Feature, min: number, parentId?: string, parentType?: string): string;
+export declare function stringifyGBK({ features, assemblyName, session, }: {
+    assemblyName: string;
+    session: AbstractSessionModel;
+    features: Feature[];
+}): Promise<string>;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.js

@@ -0,0 +1,108 @@
+import { fetchSequence } from "./fetchSequence.js";
+import { max, min } from "../../../util/index.js";
+const coreFields = new Set([
+    'uniqueId',
+    'refName',
+    'source',
+    'type',
+    'start',
+    'end',
+    'strand',
+    'parent',
+    'parentId',
+    'score',
+    'subfeatures',
+    'phase',
+]);
+const blank = '                     ';
+const retitle = {
+    name: 'Name',
+};
+function fmt(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(o => fmt(o)).join(',');
+    }
+    else if (typeof obj === 'object') {
+        return JSON.stringify(obj);
+    }
+    else {
+        return `${obj}`;
+    }
+}
+function formatTags(f, parentId, parentType) {
+    return [
+        parentId && parentType ? `${blank}/${parentType}="${parentId}"` : '',
+        f.get('id') ? `${blank}/name=${f.get('id')}` : '',
+        ...Object.keys(f.toJSON())
+            .filter(tag => !coreFields.has(tag))
+            .map(tag => [tag, fmt(f.get(tag))])
+            .filter(tag => !!tag[1] && tag[0] !== parentType)
+            .map(tag => `${blank}/${retitle[tag[0]] || tag[0]}="${tag[1]}"`),
+    ].filter(f => !!f);
+}
+function relativeStart(f, min) {
+    return f.get('start') - min + 1;
+}
+function relativeEnd(f, min) {
+    return f.get('end') - min;
+}
+function loc(f, min) {
+    return `${relativeStart(f, min)}..${relativeEnd(f, min)}`;
+}
+function formatFeat(f, min, parentType, parentId) {
+    const type = `${f.get('type')}`.slice(0, 16);
+    const l = loc(f, min);
+    const locstrand = f.get('strand') === -1 ? `complement(${l})` : l;
+    return [
+        `     ${type.padEnd(16)}${locstrand}`,
+        ...formatTags(f, parentType, parentId),
+    ];
+}
+function formatCDS(feats, parentId, parentType, strand, min) {
+    const cds = feats.map(f => loc(f, min));
+    const pre = `join(${cds})`;
+    const str = strand === -1 ? `complement(${pre})` : pre;
+    return feats.length
+        ? [`     ${'CDS'.padEnd(16)}${str}`, `${blank}/${parentType}="${parentId}"`]
+        : [];
+}
+export function formatFeatWithSubfeatures(feature, min, parentId, parentType) {
+    const primary = formatFeat(feature, min, parentId, parentType);
+    const subfeatures = feature.get('subfeatures') || [];
+    const cds = subfeatures.filter(f => f.get('type') === 'CDS');
+    const sansCDS = subfeatures.filter(f => f.get('type') !== 'CDS' && f.get('type') !== 'exon');
+    const newParentId = feature.get('id');
+    const newParentType = feature.get('type');
+    const newParentStrand = feature.get('strand');
+    return [
+        ...primary,
+        ...formatCDS(cds, newParentId, newParentType, newParentStrand, min),
+        ...sansCDS.flatMap(sub => formatFeatWithSubfeatures(sub, min, newParentId, newParentType)),
+    ].join('\n');
+}
+export async function stringifyGBK({ features, assemblyName, session, }) {
+    if (!features.length) {
+        return '';
+    }
+    const date = '10-JAN-1970';
+    const start = min(features.map(f => f.get('start')));
+    const end = max(features.map(f => f.get('end')));
+    const length = end - start;
+    const refName = features[0].get('refName') || '';
+    const l1 = [
+        'LOCUS'.padEnd(12),
+        `${refName}:${start + 1}..${end}`.padEnd(20),
+        ` ${length} bp`.padEnd(15),
+        ` ${'DNA'.padEnd(10)}`,
+        'linear'.padEnd(10),
+        `UNK ${date}`,
+    ].join('');
+    const l2 = 'FEATURES             Location/Qualifiers';
+    const contig = (await fetchSequence({
+        session,
+        region: { assemblyName, start, end, refName },
+    })) ?? '';
+    const lines = features.map(feat => formatFeatWithSubfeatures(feat, start));
+    const seqlines = ['ORIGIN', `\t1 ${contig}`, '//'];
+    return [l1, l2, ...lines, ...seqlines].join('\n');
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.d.ts

@@ -0,0 +1,5 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function formatMultiLevelFeat(feature: Feature, parentId?: string, parentRef?: string): string;
+export declare function stringifyGFF3({ features }: {
+    features: Feature[];
+}): string;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.js

@@ -0,0 +1,91 @@
+const coreFields = new Set([
+    'uniqueId',
+    'refName',
+    'source',
+    'type',
+    'start',
+    'end',
+    'strand',
+    'parent',
+    'parentId',
+    'score',
+    'subfeatures',
+    'phase',
+    '_lineHash',
+]);
+const retitle = {
+    id: 'ID',
+    name: 'Name',
+    alias: 'Alias',
+    parent: 'Parent',
+    target: 'Target',
+    gap: 'Gap',
+    derives_from: 'Derives_from',
+    note: 'Note',
+    description: 'Note',
+    dbxref: 'Dbxref',
+    ontology_term: 'Ontology_term',
+    is_circular: 'Is_circular',
+};
+function fmt(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(o => fmt(o)).join(',');
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        return JSON.stringify(obj);
+    }
+    else {
+        return String(obj);
+    }
+}
+function formatAttributes(f, parentId) {
+    const attributes = [];
+    if (parentId) {
+        attributes.push(`Parent=${parentId}`);
+    }
+    const tags = Object.keys(f.toJSON()).filter(tag => !coreFields.has(tag));
+    for (const tag of tags) {
+        const val = f.get(tag);
+        if (val !== undefined && val !== null) {
+            const formattedVal = fmt(val);
+            if (formattedVal) {
+                const key = retitle[tag] || tag;
+                attributes.push(`${key}=${formattedVal}`);
+            }
+        }
+    }
+    return attributes.join(';');
+}
+function formatFeat(f, parentId, parentRef) {
+    const strand = f.get('strand');
+    const score = f.get('score');
+    const phase = f.get('phase');
+    return [
+        f.get('refName') || parentRef,
+        f.get('source') || '.',
+        f.get('type') || '.',
+        f.get('start') + 1,
+        f.get('end'),
+        score !== undefined && score !== null ? score : '.',
+        strand === 1 ? '+' : strand === -1 ? '-' : '.',
+        phase !== undefined && phase !== null ? phase : '.',
+        formatAttributes(f, parentId),
+    ].join('\t');
+}
+export function formatMultiLevelFeat(feature, parentId, parentRef) {
+    const featureRefName = parentRef || feature.get('refName');
+    const featureId = feature.get('id');
+    const primary = formatFeat(feature, parentId, featureRefName);
+    return [
+        primary,
+        ...(feature
+            .get('subfeatures')
+            ?.map(sub => formatMultiLevelFeat(sub, featureId, featureRefName)) || []),
+    ].join('\n');
+}
+export function stringifyGFF3({ features }) {
+    return [
+        '##gff-version 3',
+        ...features.map(f => formatMultiLevelFeat(f)),
+    ].join('\n');
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/types.d.ts

@@ -0,0 +1,11 @@
+import type { AbstractSessionModel, Feature } from '@jbrowse/core/util';
+export interface FileTypeExporter {
+    name: string;
+    extension: string;
+    helpText?: string;
+    callback: (arg: {
+        features: Feature[];
+        session: AbstractSessionModel;
+        assemblyName: string;
+    }) => Promise<string> | string;
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/types.js

@@ -0,0 +1 @@
+export {};

package/esm/pluggableElementTypes/renderers/BoxRendererType.d.ts

@@ -0,0 +1,52 @@
+import FeatureRendererType from './FeatureRendererType.ts';
+import PrecomputedLayout from '../../util/layouts/PrecomputedLayout.ts';
+import type { RenderArgs as FeatureRenderArgs, RenderArgsDeserialized as FeatureRenderArgsDeserialized, RenderArgsSerialized as FeatureRenderArgsSerialized, RenderResults as FeatureRenderResults, ResultsDeserialized as FeatureResultsDeserialized, ResultsSerialized as FeatureResultsSerialized } from './FeatureRendererType.ts';
+import type { LayoutSessionLike, LayoutSessionProps } from './LayoutSession.ts';
+import type { RenderReturn } from './RendererType.tsx';
+import type RpcManager from '../../rpc/RpcManager.ts';
+import type { Feature, Region } from '../../util/index.ts';
+import type { BaseLayout, SerializedLayout } from '../../util/layouts/BaseLayout.ts';
+export interface RenderArgs extends FeatureRenderArgs {
+    bpPerPx: number;
+    trackInstanceId: string;
+}
+export interface RenderArgsSerialized extends FeatureRenderArgsSerialized {
+    bpPerPx: number;
+}
+export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
+    statusCallback?: (arg: string) => void;
+    bpPerPx: number;
+    trackInstanceId: string;
+}
+export interface RenderResults extends FeatureRenderResults {
+    layout?: BaseLayout<Feature> | SerializedLayout;
+}
+export interface ResultsSerialized extends FeatureResultsSerialized {
+    maxHeightReached: boolean;
+    layout: SerializedLayout;
+}
+export interface ResultsDeserialized extends FeatureResultsDeserialized {
+    maxHeightReached: boolean;
+    layout: PrecomputedLayout<string>;
+}
+export default class BoxRendererType extends FeatureRendererType {
+    layoutSessions: Record<string, LayoutSessionLike>;
+    createLayoutSession(props: LayoutSessionProps): LayoutSessionLike;
+    getLayoutSession(props: {
+        sessionId: string;
+        trackInstanceId: string;
+    }): LayoutSessionLike | undefined;
+    getWorkerSession(props: LayoutSessionProps & {
+        sessionId: string;
+        trackInstanceId: string;
+    }): LayoutSessionLike;
+    getExpandedRegion(region: Region, renderArgs: RenderArgsDeserialized): Region;
+    freeResources(args: RenderArgs): void;
+    freeResourcesInClient(rpcManager: RpcManager, args: RenderArgs): Promise<void>;
+    deserializeLayoutInClient(json: SerializedLayout): PrecomputedLayout<unknown>;
+    deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
+    createLayoutInWorker(args: RenderArgsDeserialized): BaseLayout<unknown>;
+    serializeLayout(layout: BaseLayout<unknown>, args: RenderArgsDeserialized): SerializedLayout;
+    render(renderArgs: RenderArgsDeserialized): Promise<RenderReturn>;
+    serializeResultsInWorker(results: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
+}

package/esm/pluggableElementTypes/renderers/BoxRendererType.js

@@ -0,0 +1,78 @@
+import FeatureRendererType from "./FeatureRendererType.js";
+import { LayoutSession } from "./LayoutSession.js";
+import { expandRegion } from "./util.js";
+import { readConfObject } from "../../configuration/index.js";
+import { getLayoutId } from "../../util/index.js";
+import PrecomputedLayout from "../../util/layouts/PrecomputedLayout.js";
+export default class BoxRendererType extends FeatureRendererType {
+    layoutSessions = {};
+    createLayoutSession(props) {
+        return new LayoutSession(props);
+    }
+    getLayoutSession(props) {
+        return this.layoutSessions[getLayoutId(props)];
+    }
+    getWorkerSession(props) {
+        const key = getLayoutId(props);
+        if (!this.layoutSessions[key]) {
+            this.layoutSessions[key] = this.createLayoutSession(props);
+        }
+        return this.layoutSessions[key].update(props);
+    }
+    getExpandedRegion(region, renderArgs) {
+        const { bpPerPx, config } = renderArgs;
+        const maxFeatureGlyphExpansion = readConfObject(config, 'maxFeatureGlyphExpansion') || 0;
+        const bpExpansion = Math.round(maxFeatureGlyphExpansion * bpPerPx);
+        return expandRegion(region, bpExpansion);
+    }
+    freeResources(args) {
+        const key = getLayoutId(args);
+        const session = this.layoutSessions[key];
+        if (session) {
+            const region = args.regions[0];
+            session.layout.discardRange(region.refName, region.start, region.end);
+        }
+    }
+    async freeResourcesInClient(rpcManager, args) {
+        this.freeResources(args);
+        return super.freeResourcesInClient(rpcManager, args);
+    }
+    deserializeLayoutInClient(json) {
+        return new PrecomputedLayout(json);
+    }
+    deserializeResultsInClient(result, args) {
+        const layout = this.deserializeLayoutInClient(result.layout);
+        return super.deserializeResultsInClient({
+            ...result,
+            layout,
+        }, args);
+    }
+    createLayoutInWorker(args) {
+        const { regions } = args;
+        const { layout } = this.getWorkerSession(args);
+        return layout.getSublayout(regions[0].refName);
+    }
+    serializeLayout(layout, args) {
+        const region = args.regions[0];
+        return layout.serializeRegion(this.getExpandedRegion(region, args));
+    }
+    async render(renderArgs) {
+        const features = await this.getFeatures(renderArgs);
+        const layout = this.createLayoutInWorker(renderArgs);
+        return { features, layout };
+    }
+    serializeResultsInWorker(results, args) {
+        const { features, ...rest } = super.serializeResultsInWorker(results, args);
+        const region = args.regions[0];
+        const resultLayout = results.layout;
+        const layout = resultLayout && 'serializeRegion' in resultLayout
+            ? resultLayout.serializeRegion(this.getExpandedRegion(region, args))
+            : resultLayout;
+        return {
+            ...rest,
+            layout,
+            maxHeightReached: layout.maxHeightReached,
+            features: features?.filter(f => !!layout.rectangles[f.uniqueId]),
+        };
+    }
+}

package/esm/pluggableElementTypes/renderers/CircularChordRendererType.d.ts

@@ -0,0 +1,4 @@
+import FeatureRenderer from './FeatureRendererType.ts';
+export default class CircularChordRendererType extends FeatureRenderer {
+    supportsSVG: boolean;
+}

package/esm/pluggableElementTypes/renderers/CircularChordRendererType.js

@@ -0,0 +1,4 @@
+import FeatureRenderer from "./FeatureRendererType.js";
+export default class CircularChordRendererType extends FeatureRenderer {
+    supportsSVG = true;
+}

package/esm/pluggableElementTypes/renderers/FeatureRendererType.d.ts

@@ -0,0 +1,58 @@
+import ServerSideRendererType from './ServerSideRendererType.tsx';
+import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults as ServerSideRenderResults, RenderReturn, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType.tsx';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { Feature, SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
+import type { AugmentedRegion as Region } from '../../util/types/index.ts';
+export interface RenderArgs extends ServerSideRenderArgs {
+    displayModel?: {
+        id: string;
+        selectedFeatureId?: string;
+    };
+    regions: Region[];
+    blockKey: string;
+}
+export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
+    displayModel?: {
+        id: string;
+        selectedFeatureId?: string;
+    };
+    regions: Region[];
+    blockKey: string;
+}
+export interface RenderArgsDeserialized extends ServerSideRenderArgsDeserialized {
+    displayModel: {
+        id: string;
+        selectedFeatureId?: string;
+    };
+    regions: Region[];
+    blockKey: string;
+    adapterConfig: AnyConfigurationModel;
+}
+export interface RenderResults extends ServerSideRenderResults {
+    features?: Map<string, Feature>;
+}
+export interface ResultsSerialized extends ServerSideResultsSerialized {
+    features?: SimpleFeatureSerialized[];
+}
+export interface ResultsDeserialized extends ServerSideResultsDeserialized {
+    features: Map<string, Feature>;
+    blockKey: string;
+}
+export default class FeatureRendererType extends ServerSideRendererType {
+    renderDirect(args: RenderArgs): Promise<{
+        blockKey: string;
+        reactElement?: React.ReactElement;
+        html?: string;
+    } | {
+        blockKey: string;
+        reactElement: import("react/jsx-runtime").JSX.Element | undefined;
+        html?: string;
+    }>;
+    serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
+    deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
+    serializeResultsInWorker(result: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
+    getExpandedRegion(region: Region, _renderArgs: RenderArgsDeserialized): Region;
+    getFeatures(renderArgs: RenderArgsDeserialized): Promise<Map<string, Feature>>;
+    featurePassesFilters(renderArgs: RenderArgsDeserialized, feature: Feature): boolean;
+    render(renderArgs: RenderArgsDeserialized): Promise<RenderReturn>;
+}