@jbrowse/plugin-alignments 2.10.1 → 2.10.2

package/esm/AlignmentsFeatureDetail/getSAFeatures.js

@@ -0,0 +1,37 @@
+import { getSession } from '@jbrowse/core/util';
+// locals
+import { featurizeSA, getClip, getLengthSansClipping } from '../MismatchParser';
+import { getTag } from '../util';
+export async function getSAFeatures({ view, feature, }) {
+    const { assemblyManager } = getSession(view);
+    const cigar = feature.get('CIGAR');
+    const origStrand = feature.get('strand');
+    const SA = getTag(feature, 'SA') || '';
+    const readName = feature.get('name');
+    const clipPos = getClip(cigar, 1);
+    // get the canonical refname for the read because if the
+    // read.get('refName') is chr1 and the actual fasta refName is 1 then no
+    // tracks can be opened on the top panel of the linear read vs ref
+    const assembly = await assemblyManager.waitForAssembly(view.assemblyNames[0]);
+    if (!assembly) {
+        throw new Error('assembly not found');
+    }
+    const suppAlns = featurizeSA(SA, feature.id(), origStrand, readName, true);
+    const feat = feature.toJSON();
+    feat.clipPos = clipPos;
+    feat.strand = 1;
+    feat.mate = {
+        refName: readName,
+        start: clipPos,
+        end: clipPos + getLengthSansClipping(cigar),
+    };
+    const features = [feat, ...suppAlns];
+    features.forEach((f, idx) => {
+        f.refName = (assembly === null || assembly === void 0 ? void 0 : assembly.getCanonicalRefName(f.refName)) || f.refName;
+        f.syntenyId = idx;
+        f.mate.syntenyId = idx;
+        f.mate.uniqueId = `${f.uniqueId}_mate`;
+    });
+    features.sort((a, b) => a.clipPos - b.clipPos);
+    return features;
+}

package/esm/AlignmentsFeatureDetail/index.d.ts

@@ -1,51 +1,2 @@
 import PluginManager from '@jbrowse/core/PluginManager';
-declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-export declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
-    featureData: import("mobx-state-tree").IType<any, any, any>;
-    formattedFields: import("mobx-state-tree").IType<any, any, any>;
-    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
-    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-} & {
-    type: import("mobx-state-tree").ISimpleType<"AlignmentsFeatureWidget">;
-}, {
-    error: unknown;
-} & {
-    setFeatureData(featureData: Record<string, unknown>): void;
-    clearFeatureData(): void;
-    setFormattedData(feat: Record<string, unknown>): void;
-    setExtra(type?: string | undefined, trackId?: string | undefined, maxDepth?: number | undefined): void;
-    setError(e: unknown): void;
-} & {
-    afterCreate(): void;
-}, {
-    type: "BaseFeatureWidget";
-} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
-    featureData: import("mobx-state-tree").IType<any, any, any>;
-    formattedFields: import("mobx-state-tree").IType<any, any, any>;
-    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
-    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-}>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
-    type: "BaseFeatureWidget";
-    id: string;
-    track: import("mobx-state-tree").ReferenceIdentifier | undefined;
-    view: import("mobx-state-tree").ReferenceIdentifier | undefined;
-    trackId: string | undefined;
-    trackType: string | undefined;
-    maxDepth: number | undefined;
-    formattedFields: any;
-    finalizedFeatureData: any;
-} & import("mobx-state-tree")._NotCustomized>;
-export default function register(pluginManager: PluginManager): void;
-export { configSchema };
+export default function AlignmentFeatureDetailsF(pluginManager: PluginManager): void;

package/esm/AlignmentsFeatureDetail/index.js

@@ -1,22 +1,13 @@
 import { lazy } from 'react';
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
 import WidgetType from '@jbrowse/core/pluggableElementTypes/WidgetType';
-import { stateModelFactory as baseModelFactory } from '@jbrowse/core/BaseFeatureWidget';
-const configSchema = ConfigurationSchema('AlignmentsFeatureWidget', {});
-export function stateModelFactory(pluginManager) {
-    const baseModel = baseModelFactory(pluginManager);
-    return types.compose(baseModel, types.model('AlignmentsFeatureWidget', {
-        type: types.literal('AlignmentsFeatureWidget'),
-    }));
-}
-export default function register(pluginManager) {
+import { configSchema } from './configSchema';
+import { stateModelFactory } from './stateModelFactory';
+export default function AlignmentFeatureDetailsF(pluginManager) {
     pluginManager.addWidgetType(() => new WidgetType({
         name: 'AlignmentsFeatureWidget',
         heading: 'Feature details',
-        configSchema,
+        configSchema: configSchema,
         stateModel: stateModelFactory(pluginManager),
         ReactComponent: lazy(() => import('./AlignmentsFeatureDetail')),
     }));
 }
-export { configSchema };

package/esm/AlignmentsFeatureDetail/launchBreakpointSplitView.d.ts

@@ -0,0 +1,22 @@
+import { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+import { ReducedFeature } from './getSAFeatures';
+export declare function getBreakpointSplitView({ f1, f2, view, }: {
+    f1: ReducedFeature;
+    f2: ReducedFeature;
+    view: LinearGenomeViewModel;
+}): {
+    type: string;
+    views: {
+        type: string;
+        displayedRegions: {
+            start: number;
+            end: number;
+            refName: string;
+            assemblyName: string;
+        }[];
+        hideHeader: boolean;
+        bpPerPx: number;
+        offsetPx: number;
+    }[];
+    displayName: string;
+};

package/esm/AlignmentsFeatureDetail/launchBreakpointSplitView.js

@@ -0,0 +1,46 @@
+import { getSession } from '@jbrowse/core/util';
+export function getBreakpointSplitView({ f1, f2, view, }) {
+    const { assemblyName } = view.displayedRegions[0];
+    const { assemblyManager } = getSession(view);
+    const assembly = assemblyManager.get(assemblyName);
+    if (!assembly) {
+        throw new Error(`assembly ${assemblyName} not found`);
+    }
+    if (!assembly.regions) {
+        throw new Error(`assembly ${assemblyName} regions not loaded`);
+    }
+    const topRegion = assembly.regions.find(f => f.refName === f1.refName);
+    const bottomRegion = assembly.regions.find(f => f.refName === f2.refName);
+    if (!topRegion || !bottomRegion) {
+        throw new Error(`unable to find the refName for the top or bottom of the breakpoint view`);
+    }
+    const topMarkedRegion = [{ ...topRegion }, { ...topRegion }];
+    const bottomMarkedRegion = [{ ...bottomRegion }, { ...bottomRegion }];
+    const s = f1.strand === 1 ? f1.end : f1.start;
+    const e = f2.strand === 1 ? f2.start : f2.end;
+    topMarkedRegion[0].end = s;
+    topMarkedRegion[1].start = s + 1;
+    bottomMarkedRegion[0].end = e;
+    bottomMarkedRegion[1].start = e + 1;
+    const bpPerPx = 10;
+    return {
+        type: 'BreakpointSplitView',
+        views: [
+            {
+                type: 'LinearGenomeView',
+                displayedRegions: topMarkedRegion,
+                hideHeader: true,
+                bpPerPx,
+                offsetPx: (topRegion.start + s) / bpPerPx,
+            },
+            {
+                type: 'LinearGenomeView',
+                displayedRegions: bottomMarkedRegion,
+                hideHeader: true,
+                bpPerPx,
+                offsetPx: (bottomRegion.start + e) / bpPerPx,
+            },
+        ],
+        displayName: `breakend split detail`,
+    };
+}

package/esm/AlignmentsFeatureDetail/stateModelFactory.d.ts

@@ -0,0 +1,51 @@
+import PluginManager from '@jbrowse/core/PluginManager';
+import { Instance } from 'mobx-state-tree';
+export declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("mobx-state-tree").IType<any, any, any>;
+    formattedFields: import("mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
+    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    type: import("mobx-state-tree").ISimpleType<"AlignmentsFeatureWidget">;
+}, {
+    error: unknown;
+} & {
+    setFeatureData(featureData: Record<string, unknown>): void;
+    clearFeatureData(): void;
+    setFormattedData(feat: Record<string, unknown>): void;
+    setExtra(type?: string | undefined, trackId?: string | undefined, maxDepth?: number | undefined): void;
+    setError(e: unknown): void;
+} & {
+    afterCreate(): void;
+}, {
+    type: "BaseFeatureWidget";
+} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("mobx-state-tree").IType<any, any, any>;
+    formattedFields: import("mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
+    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+}>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
+    type: "BaseFeatureWidget";
+    id: string;
+    track: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    view: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    trackId: string | undefined;
+    trackType: string | undefined;
+    maxDepth: number | undefined;
+    formattedFields: any;
+    finalizedFeatureData: any;
+} & import("mobx-state-tree")._NotCustomized>;
+export type AlignmentFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;
+export type AlignmentFeatureWidgetModel = Instance<AlignmentFeatureWidgetStateModel>;

package/esm/AlignmentsFeatureDetail/stateModelFactory.js

@@ -0,0 +1,8 @@
+import { types } from 'mobx-state-tree';
+import { stateModelFactory as baseModelFactory } from '@jbrowse/core/BaseFeatureWidget';
+export function stateModelFactory(pluginManager) {
+    const baseModel = baseModelFactory(pluginManager);
+    return types.compose(baseModel, types.model('AlignmentsFeatureWidget', {
+        type: types.literal('AlignmentsFeatureWidget'),
+    }));
+}

package/esm/AlignmentsFeatureDetail/tagInfo.d.ts

@@ -0,0 +1,63 @@
+export declare const tags: {
+    AM: string;
+    AS: string;
+    BC: string;
+    BQ: string;
+    BZ: string;
+    CB: string;
+    CC: string;
+    CM: string;
+    CO: string;
+    CP: string;
+    CQ: string;
+    CR: string;
+    CS: string;
+    CT: string;
+    CY: string;
+    E2: string;
+    FI: string;
+    FS: string;
+    FZ: string;
+    GC: string;
+    GQ: string;
+    GS: string;
+    H0: string;
+    H1: string;
+    H2: string;
+    HI: string;
+    IH: string;
+    LB: string;
+    MC: string;
+    MD: string;
+    MF: string;
+    MI: string;
+    ML: string;
+    MM: string;
+    MQ: string;
+    NH: string;
+    NM: string;
+    OA: string;
+    OC: string;
+    OP: string;
+    OQ: string;
+    OX: string;
+    PG: string;
+    PQ: string;
+    PT: string;
+    PU: string;
+    Q2: string;
+    QT: string;
+    QX: string;
+    R2: string;
+    RG: string;
+    RT: string;
+    RX: string;
+    S2: string;
+    SA: string;
+    SM: string;
+    SQ: string;
+    TC: string;
+    TS: string;
+    U2: string;
+    UQ: string;
+};

package/esm/AlignmentsFeatureDetail/tagInfo.js

@@ -0,0 +1,63 @@
+export const tags = {
+    AM: 'The smallest template-independent mapping quality in the template',
+    AS: 'Alignment score generated by aligner',
+    BC: 'Barcode sequence identifying the sample',
+    BQ: 'Offset to base alignment quality (BAQ)',
+    BZ: 'Phred quality of the unique molecular barcode bases in the {OX} tag',
+    CB: 'Cell identifier',
+    CC: 'Reference name of the next hit',
+    CM: 'Edit distance between the color sequence and the color reference (see also {NM})',
+    CO: 'Free-text comments',
+    CP: 'Leftmost coordinate of the next hit',
+    CQ: 'Color read base qualities',
+    CR: 'Cellular barcode sequence bases (uncorrected)',
+    CS: 'Color read sequence',
+    CT: 'Complete read annotation tag, used for consensus annotation dummy features',
+    CY: 'Phred quality of the cellular barcode sequence in the {CR} tag',
+    E2: 'The 2nd most likely base calls',
+    FI: 'The index of segment in the template',
+    FS: 'Segment suffix',
+    FZ: 'Flow signal intensities',
+    GC: 'Reserved for backwards compatibility reasons',
+    GQ: 'Reserved for backwards compatibility reasons',
+    GS: 'Reserved for backwards compatibility reasons',
+    H0: 'Number of perfect hits',
+    H1: 'Number of 1-difference hits (see also {NM})',
+    H2: 'Number of 2-difference hits',
+    HI: 'Query hit index',
+    IH: 'Query hit total count',
+    LB: 'Library',
+    MC: 'CIGAR string for mate/next segment',
+    MD: 'String encoding mismatched and deleted reference bases',
+    MF: 'Reserved for backwards compatibility reasons',
+    MI: 'Molecular identifier; a string that uniquely identifies the molecule from which the record was derived',
+    ML: 'Base modification probabilities',
+    MM: 'Base modifications / methylation ',
+    MQ: 'Mapping quality of the mate/next segment',
+    NH: 'Number of reported alignments that contain the query in the current record',
+    NM: 'Edit distance to the reference',
+    OA: 'Original alignment',
+    OC: 'Original CIGAR (deprecated; use {OA} instead)',
+    OP: 'Original mapping position (deprecated; use {OA} instead)',
+    OQ: 'Original base quality',
+    OX: 'Original unique molecular barcode bases',
+    PG: 'Program',
+    PQ: 'Phred likelihood of the template',
+    PT: 'Read annotations for parts of the padded read sequence',
+    PU: 'Platform unit',
+    Q2: 'Phred quality of the mate/next segment sequence in the {R2} tag',
+    QT: 'Phred quality of the sample barcode sequence in the {BC} tag',
+    QX: 'Quality score of the unique molecular identifier in the {RX} tag',
+    R2: 'Sequence of the mate/next segment in the template',
+    RG: 'Read group',
+    RT: 'Reserved for backwards compatibility reasons',
+    RX: 'Sequence bases of the (possibly corrected) unique molecular identifier',
+    S2: 'Reserved for backwards compatibility reasons',
+    SA: 'Other canonical alignments in a chimeric alignment',
+    SM: 'Template-independent mapping quality',
+    SQ: 'Reserved for backwards compatibility reasons',
+    TC: 'The number of segments in the template',
+    TS: 'Transcript strand',
+    U2: 'Phred probability of the 2nd call being wrong conditional on the best being wrong',
+    UQ: 'Phred likelihood of the segment, conditional on the mapping being correct',
+};

package/esm/BamAdapter/BamAdapter.js

@@ -139,7 +139,9 @@ export default class BamAdapter extends BaseFeatureDataAdapter {
                     }
                     if (tagFilter) {
                         const v = record.get(tagFilter.tag);
-                        if (!(v === '*' ? v !== undefined : `${v}` === tagFilter.value)) {
+                        if (!(tagFilter.value === '*'
+                            ? v !== undefined
+                            : `${v}` === tagFilter.value)) {
                             continue;
                         }
                     }

package/esm/CramAdapter/CramAdapter.js

@@ -180,7 +180,9 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
                         const v = tagFilter.tag === 'RG'
                             ? (_a = this.samHeader.readGroups) === null || _a === void 0 ? void 0 : _a[record.readGroupId]
                             : record.tags[tagFilter.tag];
-                        if (!(v === '*' ? v !== undefined : `${v}` === tagFilter.value)) {
+                        if (!(tagFilter.value === '*'
+                            ? v !== undefined
+                            : `${v}` === tagFilter.value)) {
                             continue;
                         }
                     }

package/esm/LinearPileupDisplay/SharedLinearPileupDisplayMixin.d.ts

@@ -54,20 +54,17 @@ export declare function SharedLinearPileupDisplayMixin(configSchema: AnyConfigur
         afterAttach(): void;
         setStatus(message: string): void;
         setLoading(abortController: AbortController): void;
-        setMessage(messageText: string): void;
+        setMessage(messageText: string): void; /**
+         * #action
+         */
         setRendered(props: {
             reactElement: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-            /**
-             * #action
-             */
             features: Map<string, Feature>;
             layout: any;
             maxHeightReached: boolean;
             renderProps: any;
         } | undefined): void;
-        setError(error: unknown): void; /**
-         * #action
-         */
+        setError(error: unknown): void;
         reload(): void;
         beforeDestroy(): void;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
@@ -173,11 +170,11 @@ export declare function SharedLinearPileupDisplayMixin(configSchema: AnyConfigur
         } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>; /**
+            message: string | undefined; /**
              * #property
              */
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
             type: import("mobx-state-tree").ISimpleType<string>;
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
@@ -220,7 +217,9 @@ export declare function SharedLinearPileupDisplayMixin(configSchema: AnyConfigur
 } & {
     afterAttach(): void;
 } & {
-    setCurrStatsBpPerPx(n: number): void;
+    setCurrStatsBpPerPx(n: number): void; /**
+     * #property
+     */
     setFeatureDensityStatsLimit(stats?: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats | undefined): void;
     getFeatureDensityStats(): Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats>;
     setFeatureDensityStatsP(arg: any): void;
@@ -241,13 +240,17 @@ export declare function SharedLinearPileupDisplayMixin(configSchema: AnyConfigur
 } & {
     readonly renderDelay: number;
     readonly TooltipComponent: import("react").FC<any>;
-    readonly selectedFeatureId: string | undefined;
+    readonly selectedFeatureId: string | undefined; /**
+     * #action
+     */
     readonly DisplayMessageComponent: import("react").FC<any> | undefined;
 } & {
     readonly features: import("@jbrowse/core/util/compositeMap").default<string, Feature>;
     readonly featureUnderMouse: Feature | undefined;
     getFeatureOverlapping(blockKey: string, x: number, y: number): string | undefined;
-    getFeatureByID(blockKey: string, id: string): [number, number, number, number] | undefined;
+    getFeatureByID(blockKey: string, id: string): [number, number, number, number] | undefined; /**
+     * #action
+     */
     searchFeatureByID(id: string): [number, number, number, number] | undefined;
 } & {
     addBlock(key: string, block: import("@jbrowse/core/util/blockTypes").BaseBlock): void;
@@ -458,20 +461,17 @@ export declare function SharedLinearPileupDisplayMixin(configSchema: AnyConfigur
         afterAttach(): void;
         setStatus(message: string): void;
         setLoading(abortController: AbortController): void;
-        setMessage(messageText: string): void;
+        setMessage(messageText: string): void; /**
+         * #action
+         */
         setRendered(props: {
             reactElement: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-            /**
-             * #action
-             */
             features: Map<string, Feature>;
             layout: any;
             maxHeightReached: boolean;
             renderProps: any;
         } | undefined): void;
-        setError(error: unknown): void; /**
-         * #action
-         */
+        setError(error: unknown): void;
         reload(): void;
         beforeDestroy(): void;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;

package/esm/LinearPileupDisplay/SharedLinearPileupDisplayMixin.js

@@ -17,10 +17,10 @@ import { getUniqueTagValues, FilterModel } from '../shared';
 import { createAutorun } from '../util';
 import { ColorByModel } from '../shared/color';
 // async
-const FilterByTagDlg = lazy(() => import('../shared/FilterByTag'));
-const ColorByTagDlg = lazy(() => import('./components/ColorByTag'));
-const SetFeatureHeightDlg = lazy(() => import('./components/SetFeatureHeight'));
-const SetMaxHeightDlg = lazy(() => import('./components/SetMaxHeight'));
+const FilterByTagDialog = lazy(() => import('../shared/FilterByTag'));
+const ColorByTagDialog = lazy(() => import('./components/ColorByTag'));
+const SetFeatureHeightDialog = lazy(() => import('./components/SetFeatureHeight'));
+const SetMaxHeightDialog = lazy(() => import('./components/SetMaxHeight'));
 // using a map because it preserves order
 const rendererTypes = new Map([
     ['pileup', 'PileupRenderer'],
@@ -392,7 +392,7 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                         label: 'Color by tag...',
                         onClick: () => {
                             getSession(self).queueDialog(doneCallback => [
-                                ColorByTagDlg,
+                                ColorByTagDialog,
                                 { model: self, handleClose: doneCallback },
                             ]);
                         },
@@ -410,7 +410,7 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                         icon: FilterListIcon,
                         onClick: () => {
                             getSession(self).queueDialog(doneCallback => [
-                                FilterByTagDlg,
+                                FilterByTagDialog,
                                 { model: self, handleClose: doneCallback },
                             ]);
                         },
@@ -436,7 +436,7 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                                 label: 'Manually set height',
                                 onClick: () => {
                                     getSession(self).queueDialog(doneCallback => [
-                                        SetFeatureHeightDlg,
+                                        SetFeatureHeightDialog,
                                         { model: self, handleClose: doneCallback },
                                     ]);
                                 },
@@ -447,7 +447,7 @@ export function SharedLinearPileupDisplayMixin(configSchema) {
                         label: 'Set max height...',
                         onClick: () => {
                             getSession(self).queueDialog(doneCallback => [
-                                SetMaxHeightDlg,
+                                SetMaxHeightDialog,
                                 { model: self, handleClose: doneCallback },
                             ]);
                         },

package/esm/LinearPileupDisplay/model.d.ts

@@ -45,9 +45,6 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
         ReactComponent: ({ model, }: {
             model: any;
         }) => any;
-        /**
-         * #property
-         */
         renderProps: any;
     } & {
         doReload(): void;
@@ -77,12 +74,6 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
             defaultValue: number;
             description: string;
         };
-        /**
-         * #stateModel LinearPileupDisplay
-         * #category display
-         * extends
-         *- [SharedLinearPileupDisplayMixin](../sharedlinearpileupdisplaymixin)
-         */
         height: {
             type: string;
             defaultValue: number;
@@ -98,6 +89,9 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
 } & {
     configuration: AnyConfigurationSchemaType;
     featureHeight: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+    /**
+     * #action
+     */
     noSpacing: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<boolean>>;
     fadeLikelihood: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<boolean>>;
     trackMaxHeight: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
@@ -162,15 +156,15 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
         } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
+            message: string | undefined; /**
+             * #action
+             */
         } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
             id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
             type: import("mobx-state-tree").ISimpleType<string>;
             rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
         }, {
-            rendererTypeName: string; /**
-             * #action
-             */
+            rendererTypeName: string;
             error: unknown;
             message: string | undefined;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
@@ -184,7 +178,9 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     readonly viewMenuActions: import("@jbrowse/core/ui").MenuItem[];
     regionCannotBeRendered(): null;
 } & {
-    setMessage(arg?: string | undefined): void;
+    setMessage(arg?: string | undefined): void; /**
+     * #getter
+     */
     setError(error?: unknown): void;
     setRpcDriverName(rpcDriverName: string): void;
     reload(): void;
@@ -201,9 +197,7 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     featureDensityStats: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats | undefined;
     currStatsBpPerPx: number;
 } & {
-    readonly currentBytesRequested: number; /**
-     * #property
-     */
+    readonly currentBytesRequested: number;
     readonly currentFeatureScreenDensity: number;
     readonly maxFeatureScreenDensity: any;
     readonly featureDensityStatsReady: boolean;
@@ -224,18 +218,13 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     regionCannotBeRenderedText(_region: import("@jbrowse/core/util").Region): "" | "Force load to see features";
     regionCannotBeRendered(_region: import("@jbrowse/core/util").Region): import("react").JSX.Element | null;
 } & {
-    featureIdUnderMouse: string | undefined; /**
-     * #action
-     */
+    featureIdUnderMouse: string | undefined;
     contextMenuFeature: import("@jbrowse/core/util").Feature | undefined;
 } & {
     readonly blockType: "dynamicBlocks" | "staticBlocks";
     readonly blockDefinitions: import("@jbrowse/core/util/blockTypes").BlockSet;
 } & {
     readonly renderDelay: number;
-    /**
-     * #action
-     */
     readonly TooltipComponent: import("react").FC<any>;
     readonly selectedFeatureId: string | undefined;
     readonly DisplayMessageComponent: import("react").FC<any> | undefined;
@@ -263,7 +252,9 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     afterAttach(): void;
 } & {
     colorTagMap: import("mobx").ObservableMap<string, string>;
-    featureUnderMouseVolatile: import("@jbrowse/core/util").Feature | undefined;
+    featureUnderMouseVolatile: import("@jbrowse/core/util").Feature | undefined; /**
+     * #action
+     */
     tagsReady: boolean;
 } & {
     readonly autorunReady: boolean;