@jbrowse/core 3.7.0 → 4.0.1

package/esm/BaseFeatureWidget/SequenceFeatureDetails/types.d.ts

@@ -0,0 +1,8 @@
+import type { SequenceFeatureDetailsModel } from './model.ts';
+import type { SimpleFeatureSerialized } from '../../util/index.ts';
+import type { SeqState } from '../util.tsx';
+export interface SequencePanelProps {
+    sequence: SeqState;
+    feature: SimpleFeatureSerialized;
+    model: SequenceFeatureDetailsModel;
+}

package/esm/BaseFeatureWidget/SequenceFeatureDetails/types.js

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

package/esm/BaseFeatureWidget/SequenceFeatureDetails/useSequenceData.d.ts

@@ -0,0 +1,13 @@
+import type { SimpleFeatureSerialized } from '../../util/index.ts';
+import type { ErrorState, SeqState } from '../util.tsx';
+export declare function useSequenceData({ feature, sequence, }: {
+    feature: SimpleFeatureSerialized;
+    sequence?: SeqState | ErrorState;
+}): {
+    seq: string;
+    upstream: string | undefined;
+    downstream: string | undefined;
+    cds: any[];
+    exons: any[];
+    utr: any[];
+} | undefined;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/useSequenceData.js

@@ -0,0 +1,73 @@
+import { revcom } from "../../util/index.js";
+import { calculateUTRs2, calculateUTRs, filterSuccessiveElementsWithSameStartAndEndCoord, revlist, } from "../util.js";
+function prepareSubfeatures(feature) {
+    const { start, subfeatures } = feature;
+    return (subfeatures
+        ?.sort((a, b) => a.start - b.start)
+        .map(sub => ({
+        ...sub,
+        start: sub.start - start,
+        end: sub.end - start,
+    })) || []);
+}
+function processFeatureData(children, feature) {
+    const featureType = feature.type?.toLowerCase();
+    const isMatureProteinRegion = featureType === 'mature_protein_region_of_cds';
+    const cds = isMatureProteinRegion
+        ? [{ start: 0, end: feature.end - feature.start, type: 'CDS' }]
+        : filterSuccessiveElementsWithSameStartAndEndCoord(children.filter(sub => {
+            const type = sub.type?.toLowerCase();
+            return type === 'cds' || type === 'mature_protein_region_of_cds';
+        }));
+    const exons = filterSuccessiveElementsWithSameStartAndEndCoord(children.filter(sub => sub.type === 'exon'));
+    let utr = filterSuccessiveElementsWithSameStartAndEndCoord(children.filter(sub => sub.type?.match(/utr/i)));
+    if (!utr.length && cds.length && exons.length) {
+        utr = calculateUTRs(cds, exons);
+    }
+    else if (!utr.length && cds.length && !exons.length) {
+        utr = calculateUTRs2(cds, {
+            start: 0,
+            end: feature.end - feature.start,
+            type: 'gene',
+        });
+    }
+    return {
+        cds,
+        exons,
+        utr,
+    };
+}
+function handleReverseStrand(sequence, cds, exons, utr) {
+    const { seq, upstream = '', downstream = '' } = sequence;
+    return {
+        sequence: {
+            seq: revcom(seq),
+            upstream: downstream ? revcom(downstream) : '',
+            downstream: upstream ? revcom(upstream) : '',
+        },
+        cds: revlist(cds, seq.length),
+        exons: revlist(exons, seq.length),
+        utr: revlist(utr, seq.length),
+    };
+}
+export function useSequenceData({ feature, sequence, }) {
+    const children = prepareSubfeatures(feature);
+    const { cds, exons, utr } = processFeatureData(children, feature);
+    if (!sequence || 'error' in sequence) {
+        return undefined;
+    }
+    else {
+        const { sequence: adjustedSequence, cds: adjustedCds, exons: adjustedExons, utr: adjustedUtr, } = feature.strand === -1
+            ? handleReverseStrand(sequence, cds, exons, utr)
+            : { sequence, cds, exons, utr };
+        const { seq, upstream, downstream } = adjustedSequence;
+        return {
+            seq,
+            upstream,
+            downstream,
+            cds: adjustedCds,
+            exons: adjustedExons,
+            utr: adjustedUtr,
+        };
+    }
+}

package/esm/BaseFeatureWidget/SequenceFeatureDetails/util.js

@@ -0,0 +1,42 @@
+export function splitString({ str, charactersPerRow, showCoordinates, currRemainder = 0, spacingInterval = 10, }) {
+    const numChunks = Math.ceil(str.length / charactersPerRow);
+    const segments = new Array(numChunks);
+    let positionCounter = currRemainder % spacingInterval;
+    let chunkIndex = 0;
+    let stringOffset = 0;
+    for (; chunkIndex < numChunks + 1; ++chunkIndex) {
+        const chunkSize = chunkIndex === 0 ? charactersPerRow - currRemainder : charactersPerRow;
+        const currentChunk = str.slice(stringOffset, stringOffset + chunkSize);
+        if (!currentChunk) {
+            break;
+        }
+        segments[chunkIndex] = showCoordinates
+            ? formatWithCoordinateSpacing(currentChunk, positionCounter, spacingInterval)
+            : currentChunk;
+        positionCounter = 0;
+        stringOffset += chunkSize;
+    }
+    return {
+        segments,
+        remainder: calculateRemainder(segments, chunkIndex, currRemainder, charactersPerRow),
+    };
+}
+function formatWithCoordinateSpacing(chunk, startPosition, spacingInterval) {
+    if (!chunk) {
+        return '';
+    }
+    let formattedChunk = '';
+    for (let i = 0, j = startPosition; i < chunk.length; i++, j++) {
+        if (j % spacingInterval === 0) {
+            formattedChunk += ' ';
+            j = 0;
+        }
+        formattedChunk += chunk[i];
+    }
+    return formattedChunk;
+}
+function calculateRemainder(segments, chunkIndex, currRemainder, charactersPerRow) {
+    const lastSegmentLength = segments.at(-1)?.replaceAll(' ', '').length || 0;
+    const additionalRemainder = chunkIndex < 2 ? currRemainder : 0;
+    return (lastSegmentLength + additionalRemainder) % charactersPerRow;
+}

package/esm/BaseFeatureWidget/configSchema.d.ts

@@ -0,0 +1,2 @@
+declare const configSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+export { configSchema };

package/esm/BaseFeatureWidget/configSchema.js

@@ -0,0 +1,3 @@
+import { ConfigurationSchema } from "../configuration/index.js";
+const configSchema = ConfigurationSchema('BaseFeatureWidget', {});
+export { configSchema };

package/esm/BaseFeatureWidget/index.d.ts

@@ -0,0 +1,2 @@
+export { configSchema } from './configSchema.ts';
+export { stateModelFactory } from './stateModelFactory.ts';

package/esm/BaseFeatureWidget/index.js

@@ -0,0 +1,2 @@
+export { configSchema } from "./configSchema.js";
+export { stateModelFactory } from "./stateModelFactory.js";

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -0,0 +1,101 @@
+import type PluginManager from '../PluginManager.ts';
+import type { MaybeSerializedFeat } from './types.tsx';
+import type { SimpleFeatureSerialized } from '../util/index.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function stateModelFactory(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>;
+    formattedFields: import("@jbrowse/mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>;
+    view: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    track: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    trackId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    trackType: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<{}, {
+        showCoordinatesSetting: string;
+        intronBp: number;
+        upDownBp: number;
+        upperCaseCDS: boolean;
+        charactersPerRow: number;
+        feature: SimpleFeatureSerialized | undefined;
+        mode: "" | "genomic" | "gene" | "gene_collapsed_intron" | "gene_updownstream" | "cdna" | "cds" | "genomic_sequence_updownstream" | "protein";
+    } & {
+        setFeature(f: SimpleFeatureSerialized): void;
+        setUpDownBp(f: number): void;
+        setIntronBp(f: number): void;
+        setUpperCaseCDS(f: boolean): void;
+        setShowCoordinates(f: "none" | "relative" | "genomic"): void;
+        setMode(mode: "" | "genomic" | "gene" | "gene_collapsed_intron" | "gene_updownstream" | "cdna" | "cds" | "genomic_sequence_updownstream" | "protein"): void;
+    } & {
+        readonly showCoordinates: boolean;
+        readonly showGenomicCoordsOption: boolean;
+        readonly hasCDS: boolean | undefined;
+        readonly hasExon: boolean | undefined;
+        readonly hasExonOrCDS: boolean | undefined;
+    } & {
+        afterAttach(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
+    descriptions: import("@jbrowse/mobx-state-tree").IType<Record<string, unknown> | undefined, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+}, {
+    error: unknown;
+} & {
+    setFeatureData(featureData: SimpleFeatureSerialized): void;
+    clearFeatureData(): void;
+    setFormattedData(feat: SimpleFeatureSerialized): void;
+    setExtra(type?: string, trackId?: string, maxDepth?: number): void;
+    setError(e: unknown): void;
+} & {
+    afterCreate(): void;
+}, import("@jbrowse/mobx-state-tree").ModelCreationType<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>;
+    formattedFields: import("@jbrowse/mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>;
+    view: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    track: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    trackId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    trackType: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<{}, {
+        showCoordinatesSetting: string;
+        intronBp: number;
+        upDownBp: number;
+        upperCaseCDS: boolean;
+        charactersPerRow: number;
+        feature: SimpleFeatureSerialized | undefined;
+        mode: "" | "genomic" | "gene" | "gene_collapsed_intron" | "gene_updownstream" | "cdna" | "cds" | "genomic_sequence_updownstream" | "protein";
+    } & {
+        setFeature(f: SimpleFeatureSerialized): void;
+        setUpDownBp(f: number): void;
+        setIntronBp(f: number): void;
+        setUpperCaseCDS(f: boolean): void;
+        setShowCoordinates(f: "none" | "relative" | "genomic"): void;
+        setMode(mode: "" | "genomic" | "gene" | "gene_collapsed_intron" | "gene_updownstream" | "cdna" | "cds" | "genomic_sequence_updownstream" | "protein"): void;
+    } & {
+        readonly showCoordinates: boolean;
+        readonly showGenomicCoordsOption: boolean;
+        readonly hasCDS: boolean | undefined;
+        readonly hasExon: boolean | undefined;
+        readonly hasExonOrCDS: boolean | undefined;
+    } & {
+        afterAttach(): void;
+    }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
+    descriptions: import("@jbrowse/mobx-state-tree").IType<Record<string, unknown> | undefined, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+}>>, {
+    track: import("@jbrowse/mobx-state-tree").ReferenceIdentifier | undefined;
+    view: import("@jbrowse/mobx-state-tree").ReferenceIdentifier | undefined;
+    type: "BaseFeatureWidget";
+    id: string;
+    trackId: string | undefined;
+    maxDepth: number | undefined;
+    sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").ModelSnapshotType<{}>;
+    formattedFields: any;
+    trackType: string | undefined;
+    descriptions: Record<string, unknown> | undefined;
+    finalizedFeatureData: any;
+}>;
+export type BaseFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;
+export type BaseFeatureWidgetModel = Instance<BaseFeatureWidgetStateModel>;

package/esm/BaseFeatureWidget/stateModelFactory.js

@@ -0,0 +1,96 @@
+import { addDisposer, types } from '@jbrowse/mobx-state-tree';
+import { autorun } from 'mobx';
+import { getConf } from "../configuration/index.js";
+import { getSession } from "../util/index.js";
+import { SequenceFeatureDetailsF } from "./SequenceFeatureDetails/model.js";
+import { formatSubfeatures } from "./util.js";
+import { ElementId } from "../util/types/mst.js";
+export function stateModelFactory(pluginManager) {
+    return types
+        .model('BaseFeatureWidget', {
+        id: ElementId,
+        type: types.literal('BaseFeatureWidget'),
+        featureData: types.frozen(),
+        formattedFields: types.frozen(),
+        unformattedFeatureData: types.frozen(),
+        view: types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
+        track: types.safeReference(pluginManager.pluggableMstType('track', 'stateModel')),
+        trackId: types.maybe(types.string),
+        trackType: types.maybe(types.string),
+        maxDepth: types.maybe(types.number),
+        sequenceFeatureDetails: types.optional(SequenceFeatureDetailsF(), {}),
+        descriptions: types.frozen(),
+    })
+        .volatile(() => ({
+        error: undefined,
+    }))
+        .actions(self => ({
+        setFeatureData(featureData) {
+            self.unformattedFeatureData = featureData;
+        },
+        clearFeatureData() {
+            self.featureData = undefined;
+        },
+        setFormattedData(feat) {
+            self.featureData = feat;
+        },
+        setExtra(type, trackId, maxDepth) {
+            self.trackId = trackId;
+            self.trackType = type;
+            self.maxDepth = maxDepth;
+        },
+        setError(e) {
+            self.error = e;
+        },
+    }))
+        .actions(self => ({
+        afterCreate() {
+            addDisposer(self, autorun(function featureWidgetAutorun() {
+                try {
+                    const { unformattedFeatureData, track } = self;
+                    const session = getSession(self);
+                    if (track) {
+                        self.setExtra(track.type, track.configuration.trackId, getConf(track, ['formatDetails', 'maxDepth']));
+                    }
+                    if (unformattedFeatureData) {
+                        const feature = structuredClone(unformattedFeatureData);
+                        const combine = (arg2, feature) => ({
+                            ...getConf(session, ['formatDetails', arg2], { feature }),
+                            ...getConf(track, ['formatDetails', arg2], { feature }),
+                        });
+                        if (track) {
+                            feature.__jbrowsefmt = combine('feature', feature);
+                            formatSubfeatures(feature, getConf(track, ['formatDetails', 'depth']), sub => {
+                                sub.__jbrowsefmt = combine('subfeatures', sub);
+                            });
+                        }
+                        self.setFormattedData(feature);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    self.setError(e);
+                }
+            }, { name: 'FeatureWidget' }));
+        },
+    }))
+        .preProcessSnapshot(snap => {
+        const { featureData, finalizedFeatureData, ...rest } = snap;
+        return {
+            unformattedFeatureData: featureData,
+            featureData: finalizedFeatureData,
+            ...rest,
+        };
+    })
+        .postProcessSnapshot(snap => {
+        const { unformattedFeatureData, featureData, ...rest } = snap;
+        const s2 = JSON.stringify(featureData, (_, v) => v === undefined ? null : v);
+        const featureTooLargeToBeSerialized = !s2 || s2.length > 2_000_000;
+        return {
+            finalizedFeatureData: featureTooLargeToBeSerialized
+                ? undefined
+                : JSON.parse(s2),
+            ...rest,
+        };
+    });
+}

package/esm/BaseFeatureWidget/types.d.ts

@@ -0,0 +1,22 @@
+import type React from 'react';
+import type { BaseFeatureWidgetModel } from './stateModelFactory.ts';
+import type { SimpleFeatureSerialized } from '../util/simpleFeature.ts';
+export interface Descriptors {
+    [key: string]: React.ReactNode | Descriptors;
+}
+export interface BaseProps extends BaseCardProps {
+    feature: SimpleFeatureSerialized;
+    formatter?: (val: unknown, key: string) => React.ReactNode;
+    descriptions?: Descriptors;
+    model?: BaseFeatureWidgetModel;
+}
+export interface BaseCardProps {
+    title?: string;
+    defaultExpanded?: boolean;
+    children?: React.ReactNode;
+}
+export interface SerializedFeat {
+    [key: string]: unknown;
+    subfeatures?: Record<string, unknown>[];
+}
+export type MaybeSerializedFeat = SimpleFeatureSerialized | undefined;

package/esm/BaseFeatureWidget/types.js

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

package/esm/BaseFeatureWidget/util.d.ts

@@ -0,0 +1,51 @@
+import type { SerializedFeat } from './types.tsx';
+import type { SimpleFeatureSerialized } from '../util/index.ts';
+export interface Feat {
+    start: number;
+    end: number;
+    type?: string;
+    name?: string;
+    id?: string;
+}
+export interface ParentFeat extends Feat {
+    uniqueId: string;
+    strand?: number;
+    refName: string;
+    subfeatures?: Feat[];
+    parentId?: string;
+}
+export interface SeqState {
+    seq: string;
+    upstream?: string;
+    downstream?: string;
+}
+export interface ErrorState {
+    error: string;
+}
+export declare function stitch(subfeats: {
+    start: number;
+    end: number;
+}[], sequence: string): string;
+export declare function filterSuccessiveElementsWithSameStartAndEndCoord(list: Feat[]): Feat[];
+export declare function revlist(list: Feat[], seqlen: number): {
+    start: number;
+    end: number;
+    type?: string;
+    name?: string;
+    id?: string;
+}[];
+export declare function calculateUTRs(cds: Feat[], exons: Feat[]): {
+    type: string;
+    start: number;
+    end: number;
+    name?: string;
+    id?: string;
+}[];
+export declare function calculateUTRs2(cds: Feat[], parentFeat: Feat): {
+    type: string;
+    start: number;
+    end: number;
+}[];
+export declare function ellipses(slug: string): string;
+export declare function replaceUndefinedWithNull(obj: SimpleFeatureSerialized): any;
+export declare function formatSubfeatures(obj: SerializedFeat, depth: number, parse: (obj: Record<string, unknown>) => void, currentDepth?: number, returnObj?: Record<string, unknown>): void;

package/esm/BaseFeatureWidget/util.js

@@ -0,0 +1,95 @@
+export function stitch(subfeats, sequence) {
+    return subfeats.map(sub => sequence.slice(sub.start, sub.end)).join('');
+}
+function getItemId(feat) {
+    return `${feat.start}-${feat.end}`;
+}
+export function filterSuccessiveElementsWithSameStartAndEndCoord(list) {
+    return list.filter((item, pos, ary) => !pos || getItemId(item) !== getItemId(ary[pos - 1]));
+}
+export function revlist(list, seqlen) {
+    return list
+        .map(sub => ({
+        ...sub,
+        start: seqlen - sub.end,
+        end: seqlen - sub.start,
+    }))
+        .sort((a, b) => a.start - b.start);
+}
+export function calculateUTRs(cds, exons) {
+    if (!cds.length) {
+        return [];
+    }
+    if (exons.length < cds.length) {
+        console.warn('exons.length less than cds.length, cant calculate UTR properly', { exons, cds });
+        return [];
+    }
+    const firstCds = cds.at(0);
+    const lastCds = cds.at(-1);
+    const firstCdsIdx = exons.findIndex(exon => exon.end >= firstCds.start && exon.start <= firstCds.start);
+    const lastCdsIdx = exons.findIndex(exon => exon.end >= lastCds.end && exon.start <= lastCds.end);
+    const lastCdsExon = exons[lastCdsIdx];
+    const firstCdsExon = exons[firstCdsIdx];
+    const fivePrimeUTRs = [
+        ...exons.slice(0, firstCdsIdx),
+        {
+            start: firstCdsExon.start,
+            end: firstCds.start,
+        },
+    ].map(elt => ({
+        ...elt,
+        type: 'five_prime_UTR',
+    }));
+    const threePrimeUTRs = [
+        {
+            start: lastCds.end,
+            end: lastCdsExon.end,
+        },
+        ...exons.slice(lastCdsIdx + 1),
+    ].map(elt => ({
+        ...elt,
+        type: 'three_prime_UTR',
+    }));
+    return [...fivePrimeUTRs, ...threePrimeUTRs];
+}
+export function calculateUTRs2(cds, parentFeat) {
+    if (!cds.length) {
+        return [];
+    }
+    const firstCds = cds.at(0);
+    const lastCds = cds.at(-1);
+    const fivePrimeUTRs = [
+        {
+            start: parentFeat.start,
+            end: firstCds.start,
+        },
+    ].map(elt => ({
+        ...elt,
+        type: 'five_prime_UTR',
+    }));
+    const threePrimeUTRs = [
+        {
+            start: lastCds.end,
+            end: parentFeat.end,
+        },
+    ].map(elt => ({
+        ...elt,
+        type: 'three_prime_UTR',
+    }));
+    return [...fivePrimeUTRs, ...threePrimeUTRs];
+}
+export function ellipses(slug) {
+    return slug.length > 20 ? `${slug.slice(0, 20)}...` : slug;
+}
+export function replaceUndefinedWithNull(obj) {
+    return JSON.parse(JSON.stringify(obj, (_, v) => (v === undefined ? null : v)));
+}
+export function formatSubfeatures(obj, depth, parse, currentDepth = 0, returnObj = {}) {
+    if (depth <= currentDepth) {
+        return;
+    }
+    obj.subfeatures?.map(sub => {
+        formatSubfeatures(sub, depth, parse, currentDepth + 1, returnObj);
+        parse(sub);
+    });
+}

package/esm/CorePlugin.d.ts

@@ -0,0 +1,6 @@
+import Plugin from './Plugin.ts';
+import type PluginManager from './PluginManager.ts';
+export default class CorePlugin extends Plugin {
+    name: string;
+    install(pluginManager: PluginManager): void;
+}

package/esm/CorePlugin.js

@@ -0,0 +1,24 @@
+import { lazy } from 'react';
+import { configSchema, stateModelFactory } from "./BaseFeatureWidget/index.js";
+import Plugin from "./Plugin.js";
+import CytobandAdapterF from "./data_adapters/CytobandAdapter/index.js";
+import WidgetType from "./pluggableElementTypes/WidgetType.js";
+import * as coreRpcMethods from "./rpc/coreRpcMethods.js";
+export default class CorePlugin extends Plugin {
+    name = 'CorePlugin';
+    install(pluginManager) {
+        for (const RpcMethod of Object.values(coreRpcMethods)) {
+            pluginManager.addRpcMethod(() => new RpcMethod(pluginManager));
+        }
+        CytobandAdapterF(pluginManager);
+        pluginManager.addWidgetType(() => {
+            return new WidgetType({
+                name: 'BaseFeatureWidget',
+                heading: 'Feature details',
+                configSchema,
+                stateModel: stateModelFactory(pluginManager),
+                ReactComponent: lazy(() => import("./BaseFeatureWidget/BaseFeatureDetail/index.js")),
+            });
+        });
+    }
+}

package/esm/PhasedScheduler.js

@@ -0,0 +1,25 @@
+export default class PhasedScheduler {
+    phaseCallbacks = new Map();
+    phaseOrder = [];
+    constructor(...phaseOrder) {
+        this.phaseOrder = phaseOrder;
+    }
+    add(phase, callback) {
+        if (!this.phaseOrder.includes(phase)) {
+            throw new Error(`unknown phase ${phase}`);
+        }
+        let phaseCallbacks = this.phaseCallbacks.get(phase);
+        if (!phaseCallbacks) {
+            phaseCallbacks = [];
+            this.phaseCallbacks.set(phase, phaseCallbacks);
+        }
+        phaseCallbacks.push(callback);
+    }
+    run() {
+        for (const phaseName of this.phaseOrder) {
+            for (const callback of this.phaseCallbacks.get(phaseName) || []) {
+                callback();
+            }
+        }
+    }
+}

package/esm/Plugin.d.ts

@@ -0,0 +1,13 @@
+import type PluginManager from './PluginManager.ts';
+import type { AnyConfigurationSchemaType } from './configuration/index.ts';
+export default abstract class Plugin {
+    abstract name: string;
+    url?: string;
+    version?: string;
+    install(_pluginManager: PluginManager): void;
+    configure(_pluginManager: PluginManager): void;
+    configurationSchema?: AnyConfigurationSchemaType;
+    configurationSchemaUnnamespaced?: AnyConfigurationSchemaType;
+    rootConfigurationSchema?: (arg: PluginManager) => Record<string, AnyConfigurationSchemaType>;
+}
+export type PluginConstructor = new (...args: unknown[]) => Plugin;

package/esm/Plugin.js

@@ -0,0 +1,9 @@
+export default class Plugin {
+    url;
+    version;
+    install(_pluginManager) { }
+    configure(_pluginManager) { }
+    configurationSchema;
+    configurationSchemaUnnamespaced;
+    rootConfigurationSchema;
+}