@jbrowse/plugin-variants 3.2.0 → 3.4.0

package/dist/MultiLinearVariantMatrixRenderer/makeImageData.js

@@ -8,29 +8,29 @@ const drawAlleleCount_1 = require("../shared/drawAlleleCount");
 const drawPhased_1 = require("../shared/drawPhased");
 const minorAlleleFrequencyUtils_1 = require("../shared/minorAlleleFrequencyUtils");
 async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
-    const { renderingMode: renderingMode, minorAlleleFrequencyFilter, sources, features, stopToken, } = renderArgs;
+    const { renderingMode, minorAlleleFrequencyFilter, sources, features, stopToken, lengthCutoffFilter, } = renderArgs;
     const { statusCallback = () => { } } = renderArgs;
     const h = canvasHeight / sources.length;
     (0, stopToken_1.checkStopToken)(stopToken);
-    const mafs = (0, minorAlleleFrequencyUtils_1.getFeaturesThatPassMinorAlleleFrequencyFilter)(features.values(), minorAlleleFrequencyFilter);
+    const mafs = await (0, util_1.updateStatus)('Calculating stats', statusCallback, () => (0, minorAlleleFrequencyUtils_1.getFeaturesThatPassMinorAlleleFrequencyFilter)({
+        stopToken,
+        features: features.values(),
+        minorAlleleFrequencyFilter,
+        lengthCutoffFilter,
+    }));
     (0, stopToken_1.checkStopToken)(stopToken);
     const arr = [];
     const m = mafs.length;
     const w = canvasWidth / m;
     await (0, util_1.updateStatus)('Drawing variant matrix', statusCallback, () => {
-        var _a, _b, _c;
-        let start = performance.now();
-        for (let i = 0; i < m; i++) {
-            if (performance.now() - start > 400) {
-                (0, stopToken_1.checkStopToken)(stopToken);
-                start = performance.now();
-            }
+        const colorCache = {};
+        (0, util_1.forEachWithStopTokenCheck)(mafs, stopToken, ({ feature, mostFrequentAlt }, idx) => {
+            var _a, _b, _c;
             const arr2 = [];
-            const { feature, mostFrequentAlt } = mafs[i];
             const hasPhaseSet = (_a = feature.get('FORMAT')) === null || _a === void 0 ? void 0 : _a.includes('PS');
             if (hasPhaseSet) {
                 const samp = feature.get('samples');
-                const x = (i / mafs.length) * canvasWidth;
+                const x = (idx / mafs.length) * canvasWidth;
                 const sln = sources.length;
                 for (let j = 0; j < sln; j++) {
                     const y = (j / sln) * canvasHeight;
@@ -53,8 +53,35 @@ async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
                                 }
                             }
                             else {
-                                const alleles = genotype.split(/[/|]/);
-                                (0, drawAlleleCount_1.drawColorAlleleCount)(alleles, ctx, x, y, w, h, mostFrequentAlt);
+                                let c = colorCache[genotype];
+                                if (c === undefined) {
+                                    let alt = 0;
+                                    let uncalled = 0;
+                                    let alt2 = 0;
+                                    let ref = 0;
+                                    const alleles = genotype.split(/[/|]/);
+                                    const total = alleles.length;
+                                    for (let i = 0; i < total; i++) {
+                                        const allele = alleles[i];
+                                        if (allele === mostFrequentAlt) {
+                                            alt++;
+                                        }
+                                        else if (allele === '0') {
+                                            ref++;
+                                        }
+                                        else if (allele === '.') {
+                                            uncalled++;
+                                        }
+                                        else {
+                                            alt2++;
+                                        }
+                                    }
+                                    c = (0, drawAlleleCount_1.getColorAlleleCount)(ref, alt, alt2, uncalled, total, true);
+                                    colorCache[genotype] = c;
+                                }
+                                if (c) {
+                                    (0, drawAlleleCount_1.drawColorAlleleCount)(c, ctx, x, y, w, h);
+                                }
                             }
                         }
                     }
@@ -62,7 +89,7 @@ async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
             }
             else {
                 const samp = feature.get('genotypes');
-                const x = (i / mafs.length) * canvasWidth;
+                const x = (idx / mafs.length) * canvasWidth;
                 const sln = sources.length;
                 for (let j = 0; j < sln; j++) {
                     const y = (j / sln) * canvasHeight;
@@ -82,14 +109,41 @@ async function makeImageData({ ctx, canvasWidth, canvasHeight, renderArgs, }) {
                             }
                         }
                         else {
-                            const alleles = genotype.split(/[/|]/);
-                            (0, drawAlleleCount_1.drawColorAlleleCount)(alleles, ctx, x, y, w, h, mostFrequentAlt);
+                            let c = colorCache[genotype];
+                            if (c === undefined) {
+                                let alt = 0;
+                                let uncalled = 0;
+                                let alt2 = 0;
+                                let ref = 0;
+                                const alleles = genotype.split(/[/|]/);
+                                const total = alleles.length;
+                                for (let i = 0; i < total; i++) {
+                                    const allele = alleles[i];
+                                    if (allele === mostFrequentAlt) {
+                                        alt++;
+                                    }
+                                    else if (allele === '0') {
+                                        ref++;
+                                    }
+                                    else if (allele === '.') {
+                                        uncalled++;
+                                    }
+                                    else {
+                                        alt2++;
+                                    }
+                                }
+                                c = (0, drawAlleleCount_1.getColorAlleleCount)(ref, alt, alt2, uncalled, total, true);
+                                colorCache[genotype] = c;
+                            }
+                            if (c) {
+                                (0, drawAlleleCount_1.drawColorAlleleCount)(c, ctx, x, y, w, h);
+                            }
                         }
                     }
                 }
             }
             arr.push(arr2);
-        }
+        });
     });
     return {
         mafs,

package/dist/MultiLinearVariantMatrixRenderer/types.d.ts

@@ -6,11 +6,9 @@ export interface RenderArgsDeserialized extends BoxRenderArgsDeserialized {
     minorAlleleFrequencyFilter: number;
     highResolutionScaling: number;
     height: number;
-    renderingMode: string;
-}
-export interface RenderArgsDeserializedWithFeaturesAndLayout extends RenderArgsDeserialized {
-    sources: Source[];
     features: Map<string, Feature>;
     renderingMode: string;
     statusCallback?: (arg: string) => void;
+    lengthCutoffFilter: number;
+    stopToken: string;
 }

package/dist/MultiLinearVariantRenderer/MultiVariantRenderer.d.ts

@@ -8,7 +8,17 @@ export default class MultiVariantBaseRenderer extends FeatureRendererType {
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        canvasRecordedData: any;
+        rbush: any;
+        featureGenotypeMap: {
+            [k: string]: {
+                alt: any;
+                ref: any;
+                name: any;
+                description: any;
+                length: number;
+            };
+        };
+        canvasRecordedData: Record<string, unknown>;
         reactElement?: React.ReactElement;
         html?: string;
     } | {
@@ -16,16 +26,35 @@ export default class MultiVariantBaseRenderer extends FeatureRendererType {
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        reactElement: import("react/jsx-runtime").JSX.Element;
+        rbush: any;
+        featureGenotypeMap: {
+            [k: string]: {
+                alt: any;
+                ref: any;
+                name: any;
+                description: any;
+                length: number;
+            };
+        };
+        imageData: any;
+        reactElement?: React.ReactElement;
         html?: string;
     } | {
         features: Map<string, Feature>;
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        imageData: any;
-        reactElement?: React.ReactElement;
+        rbush: any;
+        featureGenotypeMap: {
+            [k: string]: {
+                alt: any;
+                ref: any;
+                name: any;
+                description: any;
+                length: number;
+            };
+        };
+        reactElement: React.ReactElement;
         html?: string;
     }>;
 }
-export type { RenderArgsSerialized, RenderResults, ResultsDeserialized, ResultsSerialized, } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';

package/dist/MultiLinearVariantRenderer/MultiVariantRenderer.js

@@ -45,24 +45,30 @@ class MultiVariantBaseRenderer extends FeatureRendererType_1.default {
     }
     async render(renderProps) {
         const features = await this.getFeatures(renderProps);
-        const { height, regions, bpPerPx } = renderProps;
+        const { height, referenceDrawingMode, regions, bpPerPx } = renderProps;
         const region = regions[0];
         const width = (region.end - region.start) / bpPerPx;
         const { makeImageData } = await Promise.resolve().then(() => __importStar(require('./makeImageData')));
-        const rest = await (0, util_1.renderToAbstractCanvas)(width, height, renderProps, ctx => makeImageData(ctx, {
-            ...renderProps,
-            features,
-        }));
+        const ret = await (0, util_1.renderToAbstractCanvas)(width, height, renderProps, ctx => {
+            if (referenceDrawingMode === 'skip') {
+                ctx.fillStyle = '#ccc';
+                ctx.fillRect(0, 0, width, height);
+            }
+            return makeImageData(ctx, {
+                ...renderProps,
+                features,
+            });
+        });
         const results = await super.render({
             ...renderProps,
-            ...rest,
+            ...ret,
             features,
             height,
             width,
         });
         return {
             ...results,
-            ...rest,
+            ...ret,
             features: new Map(),
             height,
             width,

package/dist/MultiLinearVariantRenderer/components/{MultiVariantRendering.d.ts → MultiLinearVariantRendering.d.ts}

@@ -1,7 +1,14 @@
-import RBush from 'rbush';
 import type { Source } from '../../shared/types';
 import type { Feature } from '@jbrowse/core/util';
 import type { Region } from '@jbrowse/core/util/types';
+type SerializedRBush = any;
+interface MinimizedVariantRecord {
+    alt: string[];
+    ref: string;
+    name: string;
+    description: string;
+    length: number;
+}
 declare const MultiVariantRendering: (props: {
     regions: Region[];
     features: Map<string, Feature>;
@@ -10,10 +17,9 @@ declare const MultiVariantRendering: (props: {
     height: number;
     sources: Source[];
     scrollTop: number;
+    featureGenotypeMap: Record<string, MinimizedVariantRecord>;
     totalHeight: number;
-    rbush: RBush<{
-        genotype: string;
-    }>;
+    rbush: SerializedRBush;
     displayModel: any;
     onMouseLeave?: (event: React.MouseEvent) => void;
     onMouseMove?: (event: React.MouseEvent, arg?: Feature) => void;

package/dist/MultiLinearVariantRenderer/{MultiVariantRendering.js → components/MultiLinearVariantRendering.js}

@@ -6,29 +6,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const ui_1 = require("@jbrowse/core/ui");
+const util_1 = require("@jbrowse/core/util");
 const mobx_react_1 = require("mobx-react");
 const rbush_1 = __importDefault(require("rbush"));
+const util_2 = require("./util");
+const util_3 = require("../../VcfFeature/util");
 const MultiVariantRendering = (0, mobx_react_1.observer)(function (props) {
-    const { totalHeight, scrollTop } = props;
+    const { featureGenotypeMap, totalHeight, scrollTop } = props;
     const { rbush, displayModel } = props;
     const ref = (0, react_1.useRef)(null);
     const rbush2 = (0, react_1.useMemo)(() => new rbush_1.default().fromJSON(rbush), [rbush]);
     function getFeatureUnderMouse(eventClientX, eventClientY) {
-        var _a;
         let offsetX = 0;
         let offsetY = 0;
         if (ref.current) {
             const r = ref.current.getBoundingClientRect();
             offsetX = eventClientX - r.left;
-            offsetY = eventClientY - r.top;
+            offsetY = eventClientY - r.top - ((displayModel === null || displayModel === void 0 ? void 0 : displayModel.scrollTop) || 0);
         }
-        const ret = rbush2.search({
+        const x = rbush2.search({
             minX: offsetX,
-            maxX: offsetX + 3,
+            maxX: offsetX + 1,
             minY: offsetY,
-            maxY: offsetY + 3,
+            maxY: offsetY + 1,
         });
-        return (_a = ret[0]) === null || _a === void 0 ? void 0 : _a.genotype;
+        if (x.length) {
+            const { minX, minY, maxX, maxY, genotype, featureId, ...rest } = (0, util_2.minElt)(x, elt => elt.maxX - elt.minX);
+            const ret = featureGenotypeMap[featureId];
+            if (ret) {
+                const { ref, alt, name, description, length } = ret;
+                const alleles = (0, util_3.makeSimpleAltString)(genotype, ref, alt);
+                return {
+                    ...rest,
+                    genotype,
+                    alleles,
+                    featureName: name,
+                    description: alt.length >= 3 ? 'multiple ALT alleles' : description,
+                    length: (0, util_1.getBpDisplayStr)(length),
+                };
+            }
+        }
+        return undefined;
     }
     return ((0, jsx_runtime_1.jsx)("div", { ref: ref, onMouseMove: e => {
             var _a;

package/dist/MultiLinearVariantRenderer/components/util.d.ts

@@ -0,0 +1 @@
+export declare function minElt<T>(arr: Iterable<T>, cb: (arg: T) => number): T | undefined;

package/dist/MultiLinearVariantRenderer/components/util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minElt = minElt;
+function minElt(arr, cb) {
+    let min = Infinity;
+    let minElement;
+    for (const entry of arr) {
+        const val = cb(entry);
+        if (val < min) {
+            min = val;
+            minElement = entry;
+        }
+    }
+    return minElement;
+}

package/dist/MultiLinearVariantRenderer/index.js

@@ -5,13 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = MultiVariantRendererF;
 const MultiVariantRenderer_1 = __importDefault(require("./MultiVariantRenderer"));
-const MultiVariantRendering_1 = __importDefault(require("./components/MultiVariantRendering"));
+const MultiLinearVariantRendering_1 = __importDefault(require("./components/MultiLinearVariantRendering"));
 const configSchema_1 = __importDefault(require("./configSchema"));
 function MultiVariantRendererF(pluginManager) {
     pluginManager.addRendererType(() => {
         return new MultiVariantRenderer_1.default({
             name: 'MultiVariantRenderer',
-            ReactComponent: MultiVariantRendering_1.default,
+            ReactComponent: MultiLinearVariantRendering_1.default,
             configSchema: configSchema_1.default,
             pluginManager,
         });

package/dist/MultiLinearVariantRenderer/makeImageData.d.ts

@@ -1,4 +1,13 @@
 import type { MultiRenderArgsDeserialized } from './types';
 export declare function makeImageData(ctx: CanvasRenderingContext2D, props: MultiRenderArgsDeserialized): Promise<{
     rbush: any;
+    featureGenotypeMap: {
+        [k: string]: {
+            alt: any;
+            ref: any;
+            name: any;
+            description: any;
+            length: number;
+        };
+    };
 }>;

package/dist/MultiLinearVariantRenderer/makeImageData.js

@@ -12,56 +12,119 @@ const drawAlleleCount_1 = require("../shared/drawAlleleCount");
 const drawPhased_1 = require("../shared/drawPhased");
 const minorAlleleFrequencyUtils_1 = require("../shared/minorAlleleFrequencyUtils");
 async function makeImageData(ctx, props) {
-    const { scrollTop, minorAlleleFrequencyFilter, sources, rowHeight, features, regions, bpPerPx, renderingMode, stopToken, } = props;
+    const { scrollTop, minorAlleleFrequencyFilter, sources, rowHeight, features, regions, bpPerPx, renderingMode, stopToken, lengthCutoffFilter, referenceDrawingMode, } = props;
     const region = regions[0];
+    const { statusCallback = () => { } } = props;
     (0, stopToken_1.checkStopToken)(stopToken);
-    const mafs = (0, minorAlleleFrequencyUtils_1.getFeaturesThatPassMinorAlleleFrequencyFilter)(features.values(), minorAlleleFrequencyFilter);
+    const mafs = await (0, util_1.updateStatus)('Calculating stats', statusCallback, () => (0, minorAlleleFrequencyUtils_1.getFeaturesThatPassMinorAlleleFrequencyFilter)({
+        stopToken,
+        features: features.values(),
+        minorAlleleFrequencyFilter,
+        lengthCutoffFilter,
+    }));
     (0, stopToken_1.checkStopToken)(stopToken);
     const rbush = new rbush_1.default();
-    let start = performance.now();
-    for (const { mostFrequentAlt, feature } of mafs) {
-        if (performance.now() - start > 400) {
-            (0, stopToken_1.checkStopToken)(stopToken);
-            start = performance.now();
-        }
-        const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
-        const w = Math.max(Math.round(rightPx - leftPx), 2);
-        const samp = feature.get('genotypes');
-        let y = -scrollTop;
-        const s = sources.length;
-        for (let j = 0; j < s; j++) {
-            const { name, HP } = sources[j];
-            const genotype = samp[name];
-            const x = Math.floor(leftPx);
-            const h = Math.max(rowHeight, 1);
-            if (genotype) {
-                rbush.insert({
-                    minX: x - constants_1.f2,
-                    maxX: x + w + constants_1.f2,
-                    minY: y - constants_1.f2,
-                    maxY: y + h + constants_1.f2,
-                    genotype,
-                });
-                const isPhased = genotype.includes('|');
-                if (renderingMode === 'phased') {
-                    if (isPhased) {
-                        const alleles = genotype.split('|');
-                        (0, drawPhased_1.drawPhased)(alleles, ctx, x, y, w, h, HP);
-                    }
-                    else {
-                        ctx.fillStyle = 'black';
-                        ctx.fillRect(x - constants_1.f2, y - constants_1.f2, w + constants_1.f2, h + constants_1.f2);
+    await (0, util_1.updateStatus)('Drawing variants', statusCallback, () => {
+        (0, util_1.forEachWithStopTokenCheck)(mafs, stopToken, ({ mostFrequentAlt, feature }) => {
+            const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
+            const flen = feature.get('end') - feature.get('start');
+            const w = Math.max(Math.round(rightPx - leftPx), 2);
+            const samp = feature.get('genotypes');
+            let y = -scrollTop;
+            const s = sources.length;
+            if (renderingMode === 'phased') {
+                for (let j = 0; j < s; j++) {
+                    const { name, HP } = sources[j];
+                    const genotype = samp[name];
+                    const x = Math.floor(leftPx);
+                    const h = Math.max(rowHeight, 1);
+                    if (genotype) {
+                        const isPhased = genotype.includes('|');
+                        if (isPhased) {
+                            const alleles = genotype.split('|');
+                            if ((0, drawPhased_1.drawPhased)(alleles, ctx, x, y, w, h, HP, undefined, referenceDrawingMode === 'draw')) {
+                                rbush.insert({
+                                    minX: x,
+                                    maxX: x + w,
+                                    minY: y,
+                                    maxY: y + h,
+                                    genotype,
+                                    name,
+                                    featureId: feature.id(),
+                                });
+                            }
+                        }
+                        else {
+                            ctx.fillStyle = 'black';
+                            ctx.fillRect(x - constants_1.f2, y - constants_1.f2, w + constants_1.f2, h + constants_1.f2);
+                        }
                     }
+                    y += rowHeight;
                 }
-                else {
-                    const alleles = genotype.split(/[/|]/);
-                    (0, drawAlleleCount_1.drawColorAlleleCount)(alleles, ctx, x, y, w, h, mostFrequentAlt);
+            }
+            else {
+                const colorCache = {};
+                for (let j = 0; j < s; j++) {
+                    const { name } = sources[j];
+                    const genotype = samp[name];
+                    const x = Math.floor(leftPx);
+                    const h = Math.max(rowHeight, 1);
+                    if (genotype) {
+                        let c = colorCache[genotype];
+                        if (c === undefined) {
+                            let alt = 0;
+                            let uncalled = 0;
+                            let alt2 = 0;
+                            let ref = 0;
+                            const alleles = genotype.split(/[/|]/);
+                            const total = alleles.length;
+                            for (let i = 0; i < total; i++) {
+                                const allele = alleles[i];
+                                if (allele === mostFrequentAlt) {
+                                    alt++;
+                                }
+                                else if (allele === '0') {
+                                    ref++;
+                                }
+                                else if (allele === '.') {
+                                    uncalled++;
+                                }
+                                else {
+                                    alt2++;
+                                }
+                            }
+                            c = (0, drawAlleleCount_1.getColorAlleleCount)(ref, alt, alt2, uncalled, total, referenceDrawingMode === 'draw');
+                            colorCache[genotype] = c;
+                        }
+                        if (c) {
+                            (0, drawAlleleCount_1.drawColorAlleleCount)(c, ctx, x, y, w, h, feature.get('type'), feature.get('strand'), flen > 5 ? 0.75 : 1);
+                            rbush.insert({
+                                minX: x,
+                                maxX: x + w,
+                                minY: y,
+                                maxY: y + h,
+                                genotype,
+                                name,
+                                featureId: feature.id(),
+                            });
+                        }
+                    }
+                    y += rowHeight;
                 }
             }
-            y += rowHeight;
-        }
-    }
+        });
+    });
     return {
         rbush: rbush.toJSON(),
+        featureGenotypeMap: Object.fromEntries(mafs.map(({ feature }) => [
+            feature.id(),
+            {
+                alt: feature.get('ALT'),
+                ref: feature.get('REF'),
+                name: feature.get('name'),
+                description: feature.get('description'),
+                length: feature.get('end') - feature.get('start'),
+            },
+        ])),
     };
 }

package/dist/MultiLinearVariantRenderer/types.d.ts

@@ -16,4 +16,6 @@ export interface MultiRenderArgsDeserialized extends RenderArgsDeserializedWithF
     rowHeight: number;
     scrollTop: number;
     minorAlleleFrequencyFilter: number;
+    lengthCutoffFilter: number;
+    statusCallback?: (arg: string) => void;
 }

package/dist/MultiVariantBaseRenderer.d.ts

@@ -22,7 +22,7 @@ export default abstract class MultiVariantBaseRenderer extends FeatureRendererTy
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        canvasRecordedData: any;
+        canvasRecordedData: Record<string, unknown>;
         reactElement?: React.ReactElement;
         html?: string;
     } | {
@@ -30,15 +30,15 @@ export default abstract class MultiVariantBaseRenderer extends FeatureRendererTy
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        reactElement: import("react/jsx-runtime").JSX.Element;
+        imageData: any;
+        reactElement?: React.ReactElement;
         html?: string;
     } | {
         features: Map<string, Feature>;
         height: number;
         width: number;
         containsNoTransferables: boolean;
-        imageData: any;
-        reactElement?: React.ReactElement;
+        reactElement: React.ReactElement;
         html?: string;
     }>;
     abstract draw<T extends RenderArgsDeserializedWithFeatures>(ctx: CanvasRenderingContext2D, props: T): Promise<Record<string, unknown> | undefined>;

package/dist/SplitVcfTabixAdapter/SplitVcfTabixAdapter.d.ts

@@ -15,5 +15,4 @@ export default class SplitVcfTabixAdapter extends BaseFeatureDataAdapter {
     getSources(): Promise<{
         name: string;
     }[]>;
-    freeResources(): void;
 }

package/dist/SplitVcfTabixAdapter/SplitVcfTabixAdapter.js

@@ -88,6 +88,5 @@ class SplitVcfTabixAdapter extends BaseAdapter_1.BaseFeatureDataAdapter {
                 .filter(f => s.has(f.name));
         }
     }
-    freeResources() { }
 }
 exports.default = SplitVcfTabixAdapter;

package/dist/SplitVcfTabixAdapter/configSchema.js

@@ -19,9 +19,11 @@ const SplitVcfTabixAdapter = (0, configuration_1.ConfigurationSchema)('SplitVcfT
         type: 'fileLocation',
         defaultValue: {
             uri: '/path/to/samples.tsv',
-            description: 'tsv with header like name\tpopulation\tetc. where the first column is required, and is the sample names',
+            description: 'tsv with header like "name\tpopulation\tetc" where the first column is required, and corresponds to the sample names in the VCF files',
             locationType: 'UriLocation',
         },
     },
-}, { explicitlyTyped: true });
+}, {
+    explicitlyTyped: true,
+});
 exports.default = SplitVcfTabixAdapter;

package/dist/VariantFeatureWidget/AltFormatter.d.ts

@@ -0,0 +1,4 @@
+export default function AltFormatter({ value, ref, }: {
+    value: string;
+    ref: string;
+}): string | import("react/jsx-runtime").JSX.Element;

package/dist/VariantFeatureWidget/AltFormatter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = AltFormatter;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const util_1 = require("../VcfFeature/util");
+function AltFormatter({ value, ref, }) {
+    const [show, setShow] = (0, react_1.useState)(false);
+    const alt = (0, util_1.getMinimalDesc)(ref, value);
+    return alt !== value ? ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("button", { onClick: () => {
+                    setShow(!show);
+                }, children: show ? 'Show simplified ALT' : 'Show raw ALT' }), ' ', show ? value : (0, util_1.getMinimalDesc)(ref, value)] })) : (value);
+}

package/dist/VariantFeatureWidget/Checkbox2.js

@@ -3,13 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = Checkbox2;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const material_1 = require("@mui/material");
-const mui_1 = require("tss-react/mui");
-const useStyles = (0, mui_1.makeStyles)()({
-    block: {
-        display: 'block',
-    },
-});
 function Checkbox2({ checked, disabled, label, onChange, }) {
-    const { classes } = useStyles();
-    return ((0, jsx_runtime_1.jsx)(material_1.FormControlLabel, { disabled: disabled, className: classes.block, control: (0, jsx_runtime_1.jsx)(material_1.Checkbox, { checked: checked, onChange: onChange }), label: label }));
+    return ((0, jsx_runtime_1.jsx)(material_1.FormControlLabel, { disabled: disabled, control: (0, jsx_runtime_1.jsx)(material_1.Checkbox, { checked: checked, onChange: onChange }), label: (0, jsx_runtime_1.jsx)(material_1.Typography, { variant: "body2", children: label }) }));
 }