@jbrowse/core 4.2.1 → 5.0.0-beta.1

package/esm/BaseFeatureWidget/SequenceFeatureDetails/util.js

@@ -1,42 +1,164 @@
+/**
+ * Splits a string into chunks for display with optional coordinate spacing.
+ * The first chunk may be short to complete a row partially filled by a prior
+ * call (tracked via `currRemainder`).
+ */
 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;
+    const segments = [];
+    // the column the first chunk starts at, not an offset within a spacing group:
+    // a segment continuing a row at a multiple of spacingInterval still needs the
+    // separator space before its first character
+    let positionCounter = currRemainder;
     let stringOffset = 0;
-    for (; chunkIndex < numChunks + 1; ++chunkIndex) {
-        const chunkSize = chunkIndex === 0 ? charactersPerRow - currRemainder : charactersPerRow;
+    let isFirstChunk = true;
+    while (stringOffset < str.length) {
+        const chunkSize = isFirstChunk
+            ? charactersPerRow - currRemainder
+            : charactersPerRow;
         const currentChunk = str.slice(stringOffset, stringOffset + chunkSize);
-        if (!currentChunk) {
-            break;
-        }
-        segments[chunkIndex] = showCoordinates
+        segments.push(showCoordinates
             ? formatWithCoordinateSpacing(currentChunk, positionCounter, spacingInterval)
-            : currentChunk;
+            : currentChunk);
         positionCounter = 0;
         stringOffset += chunkSize;
+        isFirstChunk = false;
     }
+    const lastSegmentLength = segments.at(-1)?.replaceAll(' ', '').length ?? 0;
+    const carryRemainder = segments.length <= 1 ? currRemainder : 0;
     return {
         segments,
-        remainder: calculateRemainder(segments, chunkIndex, currRemainder, charactersPerRow),
+        remainder: (lastSegmentLength + carryRemainder) % charactersPerRow,
     };
 }
+/**
+ * Width to pad every coordinate label in a panel to, so all rows start their
+ * sequence at the same column. Row labels step by charactersPerRow from
+ * firstCoord, so the longest is at one end of the panel or the other. Floors at
+ * 4 to keep the historical look of short (feature-relative) labels.
+ */
+export function coordLabelWidth({ firstCoord, totalLength, charactersPerRow, strand, }) {
+    const rows = Math.max(1, Math.ceil(totalLength / charactersPerRow));
+    const lastCoord = firstCoord + (rows - 1) * charactersPerRow * strand;
+    return Math.max(4, `${firstCoord}`.length, `${lastCoord}`.length);
+}
+/**
+ * The strand the panel reads. A minus-strand feature is already rendered
+ * reverse-complemented, so the revcomp toggle flips whichever strand the
+ * feature would otherwise be read on rather than forcing the minus strand.
+ */
+export function displayStrand(feature, revcomp) {
+    return (feature.strand === -1) !== revcomp ? -1 : 1;
+}
+/**
+ * Computes the coordinate multiplier and genomic coordinate start for a sequence
+ * display. Both GenomicSequence and CDNASequence use this to initialize their
+ * coordinate-tracking state.
+ */
+export function computeCoordProps({ feature, useGenomicCoords, upstream, revcomp, }) {
+    const strand = displayStrand(feature, revcomp);
+    const mult = useGenomicCoords ? strand : 1;
+    const coordStart = useGenomicCoords
+        ? strand > 0
+            ? feature.start + 1 - (upstream?.length ?? 0)
+            : feature.end + (upstream?.length ?? 0)
+        : 0;
+    return { mult, coordStart };
+}
+/**
+ * The exonic blocks making up a transcript, feature-relative. Without exon
+ * subfeatures the CDS blocks stand in for them, the first and last stretched to
+ * the feature bounds so the untranslated flanks are still rendered.
+ *
+ * The exon path returns them verbatim, and that asymmetry is deliberate: exons
+ * that do not reach the feature's bounds are the annotation saying the flanks
+ * are not exonic, which is what CAT/liftoff means when it spans a transcript
+ * over the source alignment and emits exons only where the CDS is supported.
+ * Stretching those to the bounds the way the CDS branch does would fabricate
+ * exonic sequence out of intron. `CDNASequence` renders the untiled stretch
+ * uncolored instead, which is what keeps its genomic labels honest.
+ */
+export function transcriptRegions({ cds, exons, featureLength, }) {
+    return exons.length
+        ? exons
+        : cds.map((sub, idx) => ({
+            start: idx === 0 ? 0 : sub.start,
+            end: idx === cds.length - 1 ? featureLength : sub.end,
+        }));
+}
+/**
+ * Splits an exonic region into its coding and untranslated stretches. `cds` must
+ * be sorted by start. A region no CDS overlaps comes back wholly untranslated,
+ * so a CDS annotated outside the exons degrades to an uncolored transcript
+ * rather than dropping sequence or throwing.
+ */
+export function splitRegionByCds(region, cds) {
+    const parts = [];
+    let pos = region.start;
+    for (const sub of cds) {
+        const start = Math.max(sub.start, region.start);
+        const end = Math.min(sub.end, region.end);
+        if (start < end) {
+            if (start > pos) {
+                parts.push({ start: pos, end: start, isCds: false });
+            }
+            parts.push({ start, end, isCds: true });
+            pos = end;
+        }
+    }
+    if (pos < region.end) {
+        parts.push({ start: pos, end: region.end, isCds: false });
+    }
+    return parts;
+}
+/**
+ * Returns the display string for an intron. Collapses long introns to
+ * "NNN...NNN" when collapseIntron is true and the intron exceeds 2*intronBp.
+ */
+export function getIntronDisplayStr(intron, intronBp, collapseIntron) {
+    return collapseIntron && intron.length > intronBp * 2
+        ? `${intron.slice(0, intronBp)}...${intron.slice(-intronBp)}`
+        : intron;
+}
+/**
+ * Formats a string chunk with spaces at regular intervals to help with
+ * coordinate visualization.
+ */
 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;
+    let result = '';
+    for (let i = 0; i < chunk.length; i++) {
+        const pos = startPosition + i;
+        if (pos > 0 && pos % spacingInterval === 0) {
+            result += ' ';
         }
-        formattedChunk += chunk[i];
+        result += chunk[i];
     }
-    return formattedChunk;
+    return result;
 }
-function calculateRemainder(segments, chunkIndex, currRemainder, charactersPerRow) {
-    const lastSegmentLength = segments.at(-1)?.replaceAll(' ', '').length || 0;
-    const additionalRemainder = chunkIndex < 2 ? currRemainder : 0;
-    return (lastSegmentLength + additionalRemainder) % charactersPerRow;
+/**
+ * The sequence panel as FASTA, for the copy and download rows.
+ *
+ * Not the panel's text. The panel draws a position label down its left edge and
+ * a space every ten bases, both of which are there to be read by a person, and
+ * a `>`-headed file carrying either parses nowhere — the header promises a tool
+ * it can be parsed and then hands it `1201   ACGTACGTAC ACGT…`. So: drop every
+ * `[data-no-fasta]` node (the legend, and those labels), then strip the spacing
+ * out of each sequence line. A line opening with `>` is a header and survives
+ * whole, since a FASTA description is words.
+ *
+ * What the panel renders is still `el.textContent`, and that is what the HTML
+ * rows copy — coordinates, colors and all. Selecting the panel by hand gets it
+ * too, so nothing here is the only way to a positioned readout.
+ */
+export function getSequenceFasta(el) {
+    const clone = el.cloneNode(true);
+    for (const node of clone.querySelectorAll('[data-no-fasta]')) {
+        node.remove();
+    }
+    return (clone.textContent || '')
+        .split('\n')
+        .map(line => (line.startsWith('>') ? line : line.replaceAll(/\s/g, '')))
+        .join('\n');
 }

package/esm/BaseFeatureWidget/configSchema.js

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

package/esm/BaseFeatureWidget/formatDetails.d.ts

@@ -0,0 +1,38 @@
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { SimpleFeatureSerialized } from '../util/index.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Anything carrying a `formatDetails` sub-schema: the session (whose
+ * `configuration.formatDetails` applies to every track) and the clicked
+ * feature's track. The track is absent when the widget was opened without one,
+ * or outlived the one it had -- it is a `safeReference` -- and the session-wide
+ * tier still has to run in that case.
+ */
+export interface FormatDetailsHolder extends IStateTreeNode {
+    configuration: AnyConfigurationModel;
+}
+export interface FormatDetailsTiers {
+    session: FormatDetailsHolder;
+    track?: FormatDetailsHolder;
+}
+/**
+ * `depth` or `maxDepth`: the track's value when the track sets one, else the
+ * session's, else unset.
+ *
+ * These override rather than merge, unlike the callback objects. That is only
+ * expressible because both are `maybeNumber` slots with no `defaultValue` --
+ * given a schema default the track reported a value whether or not anyone set
+ * one, so the session-wide tier could never apply to a track, and every real
+ * config has a track.
+ */
+export declare function formatDetailsNumber(tiers: FormatDetailsTiers, slot: string): number | undefined;
+/**
+ * A copy of the feature with each tier's callback output merged onto it (and
+ * onto its subfeatures, down to `depth`) as `__jbrowsefmt`, which the detail
+ * components spread over the raw fields at render.
+ *
+ * `__jbrowsefmt` is attached only where a callback produced something, so a
+ * config with no `formatDetails` at all leaves the feature exactly as it came
+ * in rather than stamping empty objects through the persisted snapshot.
+ */
+export declare function applyFormatDetails(tiers: FormatDetailsTiers, featureData: SimpleFeatureSerialized): SimpleFeatureSerialized;

package/esm/BaseFeatureWidget/formatDetails.js

@@ -0,0 +1,103 @@
+/**
+ * @module
+ * Resolving the `formatDetails` config hook across its two tiers, on behalf of
+ * the feature-details widget's autorun. Plain functions rather than model
+ * members: an MST action runs untracked, so folding these into one would leave
+ * the autorun with no observable reads and fire it exactly once.
+ */
+import { DEFAULT_FORMAT_DETAILS_DEPTH, getConf, mergeFormatCallbacks, } from '../configuration/index.js';
+import { isObject } from '../util/index.js';
+import { isEmpty } from './BaseFeatureDetail/util.js';
+import { formatSubfeatures } from './util.js';
+/** Both tiers of one slot, session first, so a spread puts the track on top. */
+function readTiers({ session, track }, slot, args) {
+    return [
+        getConf(session, ['formatDetails', slot], args),
+        track ? getConf(track, ['formatDetails', slot], args) : undefined,
+    ];
+}
+/**
+ * Whether either tier **declares** a callback for `slot`, read RAW off the
+ * config node.
+ *
+ * Deliberately not `readTiers`: "is anything configured here" and "what does
+ * this produce for this feature" are different questions, and an arg-less read
+ * of a `jexl:` slot answers the second one badly — it evaluates the user's
+ * expression against a context where `feature` is undefined (see
+ * `configuration/CLAUDE.md`), which is a throw or a junk value, per tier, just
+ * to find out the slot exists.
+ *
+ * Both callback slots default to `{}`, so a config that never mentions
+ * `formatDetails` answers false for both and `applyFormatDetails` can hand the
+ * feature straight back. That is the whole point of asking: the walk it skips
+ * is proportional to the subfeature tree, and the tree can be very large (a
+ * RefSeq BRCA1 is 368 transcripts, ~16k nodes) while the config that formats
+ * none of it is the overwhelmingly common one.
+ */
+function declaresCallback({ session, track }, slot) {
+    return [session, track].some(holder => {
+        // raw property access, not a reader: see above
+        const sub = holder?.configuration.formatDetails;
+        const value = sub?.[slot];
+        // a `jexl:` slot is a string; a plain-object slot counts only when it has
+        // keys, since `{}` is the schema default and merges to nothing
+        return typeof value === 'string'
+            ? value !== ''
+            : isObject(value) && !isEmpty(value);
+    });
+}
+/**
+ * `depth` or `maxDepth`: the track's value when the track sets one, else the
+ * session's, else unset.
+ *
+ * These override rather than merge, unlike the callback objects. That is only
+ * expressible because both are `maybeNumber` slots with no `defaultValue` --
+ * given a schema default the track reported a value whether or not anyone set
+ * one, so the session-wide tier could never apply to a track, and every real
+ * config has a track.
+ */
+export function formatDetailsNumber(tiers, slot) {
+    const [fromSession, fromTrack] = readTiers(tiers, slot);
+    return typeof fromTrack === 'number'
+        ? fromTrack
+        : typeof fromSession === 'number'
+            ? fromSession
+            : undefined;
+}
+/**
+ * A copy of the feature with each tier's callback output merged onto it (and
+ * onto its subfeatures, down to `depth`) as `__jbrowsefmt`, which the detail
+ * components spread over the raw fields at render.
+ *
+ * `__jbrowsefmt` is attached only where a callback produced something, so a
+ * config with no `formatDetails` at all leaves the feature exactly as it came
+ * in rather than stamping empty objects through the persisted snapshot.
+ */
+export function applyFormatDetails(tiers, featureData) {
+    const hasFeature = declaresCallback(tiers, 'feature');
+    const hasSubfeatures = declaresCallback(tiers, 'subfeatures');
+    // Nothing declared by either tier: the result is the input, so return the
+    // input. The clone and the per-node walk below are both proportional to the
+    // subfeature tree and both produce nothing here, and this is the default
+    // config -- most tracks never set `formatDetails` at all.
+    if (!hasFeature && !hasSubfeatures) {
+        return featureData;
+    }
+    const feature = structuredClone(featureData);
+    if (hasFeature) {
+        const fmt = mergeFormatCallbacks(...readTiers(tiers, 'feature', { feature }));
+        if (!isEmpty(fmt)) {
+            feature.__jbrowsefmt = fmt;
+        }
+    }
+    if (hasSubfeatures) {
+        const depth = formatDetailsNumber(tiers, 'depth') ?? DEFAULT_FORMAT_DETAILS_DEPTH;
+        formatSubfeatures(feature, depth, sub => {
+            const subFmt = mergeFormatCallbacks(...readTiers(tiers, 'subfeatures', { feature: sub }));
+            if (!isEmpty(subFmt)) {
+                sub.__jbrowsefmt = subFmt;
+            }
+        });
+    }
+    return feature;
+}

package/esm/BaseFeatureWidget/index.d.ts

@@ -1,3 +1,5 @@
 export { configSchema } from './configSchema.ts';
-export type { MaybeSerializedFeat } from './types.tsx';
+export type { Descriptors, MaybeSerializedFeat } from './types.tsx';
+export type { SequenceHoverPosition, ShowCoordinatesMode, } from './SequenceFeatureDetails/model.ts';
 export { stateModelFactory } from './stateModelFactory.ts';
+export type { BaseFeatureWidgetModel, BaseFeatureWidgetStateModel, } from './stateModelFactory.ts';

package/esm/BaseFeatureWidget/index.js

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

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -1,100 +1,118 @@
 import type PluginManager from '../PluginManager.ts';
-import type { MaybeSerializedFeat } from './types.tsx';
 import type { SimpleFeatureSerialized } from '../util/index.ts';
+import type { SequenceHoverPosition } from './SequenceFeatureDetails/model.ts';
+import type { Descriptors, MaybeSerializedFeat } from './types.tsx';
 import type { Instance } from '@jbrowse/mobx-state-tree';
+/**
+ * #stateModel BaseFeatureWidget
+ * displays data about features, allowing configuration callbacks to modify the
+ * contents of what is displayed
+ *
+ * see: formatDetails-\>feature,formatDetails-\>subfeatures
+ */
 export declare function stateModelFactory(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
     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>;
+    /**
+     * #property
+     */
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<"BaseFeatureWidget">;
+    /**
+     * #property
+     */
+    featureData: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>, [undefined]>;
+    /**
+     * #property
+     */
+    unformattedFeatureData: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>, [undefined]>;
+    /**
+     * #property
+     */
     view: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    /**
+     * #property
+     */
     track: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<import("@jbrowse/mobx-state-tree").IAnyType>>;
+    /**
+     * #property
+     */
     trackId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    /**
+     * #property
+     */
     trackType: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    /**
+     * #property
+     */
     maxDepth: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
+    /**
+     * #property
+     */
     sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<{}, {
-        showCoordinatesSetting: string;
+        showCoordinatesSetting: import("./index.ts").ShowCoordinatesMode;
         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;
+        setCharactersPerRow(f: number): void;
+        setShowCoordinates(f: import("./index.ts").ShowCoordinatesMode): void;
     } & {
         readonly showCoordinates: boolean;
-        readonly showGenomicCoordsOption: boolean;
-        readonly hasCDS: boolean | undefined;
-        readonly hasExon: boolean | undefined;
-        readonly hasExonOrCDS: boolean | undefined;
-    } & {
-        afterCreate(): 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>;
+    /**
+     * #property
+     */
+    descriptions: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<Descriptors | undefined, Descriptors | undefined, Descriptors | undefined>, [undefined]>;
 }, {
     error: unknown;
+    sequenceHoverPosition: SequenceHoverPosition | undefined;
 } & {
+    /**
+     * #action
+     */
+    setSequenceHoverPosition(pos: SequenceHoverPosition | undefined): void;
+    /**
+     * #action
+     */
     setFeatureData(featureData: SimpleFeatureSerialized): void;
+    /**
+     * #action
+     */
     clearFeatureData(): void;
+    /**
+     * #action
+     */
     setFormattedData(feat: SimpleFeatureSerialized): void;
-    setExtra(type?: string, trackId?: string, maxDepth?: number): void;
+    /**
+     * #action
+     */
+    setTrackInfo(type?: string, trackId?: string): void;
+    /**
+     * #action
+     */
+    setMaxDepth(maxDepth?: number): void;
+    /**
+     * #action
+     */
     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;
-    } & {
-        afterCreate(): 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";
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, {
     id: string;
+    type: "BaseFeatureWidget";
+    view: import("@jbrowse/mobx-state-tree").ReferenceIdentifier | undefined;
+    track: import("@jbrowse/mobx-state-tree").ReferenceIdentifier | undefined;
     trackId: string | undefined;
+    trackType: string | undefined;
     maxDepth: number | undefined;
     sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").ModelSnapshotType<{}>;
-    formattedFields: any;
-    trackType: string | undefined;
-    descriptions: Record<string, unknown> | undefined;
+    descriptions: Descriptors | undefined;
     finalizedFeatureData: any;
 }>;
 export type BaseFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;