@jbrowse/plugin-alignments 2.17.0 → 3.0.0

package/dist/SNPCoverageRenderer/configSchema.js

@@ -1,47 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const configuration_1 = require("@jbrowse/core/configuration");
-/**
- * #config SNPCoverageRenderer
- */
-function x() { } // eslint-disable-line @typescript-eslint/no-unused-vars
+function x() { }
 const SNPCoverageRenderer = (0, configuration_1.ConfigurationSchema)('SNPCoverageRenderer', {
-    /**
-     * #slot
-     */
     clipColor: {
         type: 'color',
         description: 'the color of the clipping marker',
         defaultValue: 'red',
     },
-    /**
-     * #slot
-     */
     indicatorThreshold: {
         type: 'number',
         description: 'the proportion of reads containing a insertion/clip indicator',
         defaultValue: 0.4,
     },
-    /**
-     * #slot
-     */
-    drawArcs: {
+    showArcs: {
         type: 'boolean',
         description: 'Draw sashimi-style arcs for intron features',
         defaultValue: true,
     },
-    /**
-     * #slot
-     */
-    drawInterbaseCounts: {
+    showInterbaseCounts: {
         type: 'boolean',
         description: 'draw count "upsidedown histogram" of the interbase events that don\'t contribute to the coverage count so are not drawn in the normal histogram',
         defaultValue: true,
     },
-    /**
-     * #slot
-     */
-    drawIndicators: {
+    showInterbaseIndicators: {
         type: 'boolean',
         description: 'draw a triangular indicator where an event has been detected',
         defaultValue: true,

package/dist/SNPCoverageRenderer/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function register(pluginManager: PluginManager): void;

package/dist/SNPCoverageRenderer/index.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = register;
-const configSchema_1 = __importDefault(require("./configSchema"));
-const SNPCoverageRenderer_1 = __importDefault(require("./SNPCoverageRenderer"));
 const plugin_wiggle_1 = require("@jbrowse/plugin-wiggle");
+const SNPCoverageRenderer_1 = __importDefault(require("./SNPCoverageRenderer"));
+const configSchema_1 = __importDefault(require("./configSchema"));
 function register(pluginManager) {
     pluginManager.addRendererType(() => new SNPCoverageRenderer_1.default({
         name: 'SNPCoverageRenderer',

package/dist/SNPCoverageRenderer/makeImage.d.ts

@@ -0,0 +1,2 @@
+import type { RenderArgsDeserializedWithFeatures } from './types';
+export declare function makeImage(ctx: CanvasRenderingContext2D, props: RenderArgsDeserializedWithFeatures): Promise<void>;

package/dist/SNPCoverageRenderer/makeImage.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeImage = makeImage;
+const configuration_1 = require("@jbrowse/core/configuration");
+const ui_1 = require("@jbrowse/core/ui");
+const util_1 = require("@jbrowse/core/util");
+const stopToken_1 = require("@jbrowse/core/util/stopToken");
+const plugin_wiggle_1 = require("@jbrowse/plugin-wiggle");
+const util_2 = require("../shared/util");
+const INTERBASE_INDICATOR_WIDTH = 7;
+const INTERBASE_INDICATOR_HEIGHT = 4.5;
+const MINIMUM_INTERBASE_INDICATOR_READ_DEPTH = 7;
+const complementBase = {
+    C: 'G',
+    G: 'C',
+    A: 'T',
+    T: 'A',
+};
+const fudgeFactor = 0.6;
+async function makeImage(ctx, props) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const { features, regions, bpPerPx, colorBy, displayCrossHatches, visibleModifications = {}, scaleOpts, height: unadjustedHeight, theme: configTheme, config: cfg, ticks, stopToken, } = props;
+    const theme = (0, ui_1.createJBrowseTheme)(configTheme);
+    const region = regions[0];
+    const width = (region.end - region.start) / bpPerPx;
+    const offset = plugin_wiggle_1.YSCALEBAR_LABEL_OFFSET;
+    const height = unadjustedHeight - offset * 2;
+    const opts = { ...scaleOpts, range: [0, height] };
+    const viewScale = (0, plugin_wiggle_1.getScale)(opts);
+    const indicatorViewScale = (0, plugin_wiggle_1.getScale)({
+        ...opts,
+        range: [0, height / 2],
+        scaleType: 'linear',
+    });
+    const originY = (0, plugin_wiggle_1.getOrigin)(scaleOpts.scaleType);
+    const originLinear = (0, plugin_wiggle_1.getOrigin)('linear');
+    const indicatorThreshold = (0, configuration_1.readConfObject)(cfg, 'indicatorThreshold');
+    const showInterbaseCounts = (0, configuration_1.readConfObject)(cfg, 'showInterbaseCounts');
+    const showArcs = (0, configuration_1.readConfObject)(cfg, 'showArcs');
+    const showInterbaseIndicators = (0, configuration_1.readConfObject)(cfg, 'showInterbaseIndicators');
+    const toY = (n) => height - (viewScale(n) || 0) + offset;
+    const toHeight = (n) => toY(originY) - toY(n);
+    const toY2 = (n) => height - (indicatorViewScale(n) || 0) + offset;
+    const toHeight2 = (n) => toY2(originLinear) - toY2(n);
+    const { bases } = theme.palette;
+    const colorForBase = {
+        A: bases.A.main,
+        C: bases.C.main,
+        G: bases.G.main,
+        T: bases.T.main,
+        insertion: 'purple',
+        softclip: 'blue',
+        hardclip: 'red',
+        total: (0, configuration_1.readConfObject)(cfg, 'color'),
+        mod_NONE: 'blue',
+        cpg_meth: 'red',
+        cpg_unmeth: 'blue',
+    };
+    const feats = [...features.values()];
+    ctx.fillStyle = colorForBase.total;
+    let start = performance.now();
+    for (const feature of feats) {
+        if (feature.get('type') === 'skip') {
+            continue;
+        }
+        const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
+        const w = rightPx - leftPx + fudgeFactor;
+        const score = feature.get('score');
+        ctx.fillRect(leftPx, toY(score), w, toHeight(score));
+        if (performance.now() - start > 400) {
+            (0, stopToken_1.checkStopToken)(stopToken);
+            start = performance.now();
+        }
+    }
+    let prevTotal = 0;
+    const extraHorizontallyFlippedOffset = region.reversed ? 1 / bpPerPx : 0;
+    const drawingModifications = colorBy.type === 'modifications';
+    const drawingMethylation = colorBy.type === 'methylation';
+    const isolatedModification = (_a = colorBy.modifications) === null || _a === void 0 ? void 0 : _a.isolatedModification;
+    start = performance.now();
+    for (const feature of feats) {
+        const now = performance.now();
+        if (now - start > 400) {
+            (0, stopToken_1.checkStopToken)(stopToken);
+        }
+        if (feature.get('type') === 'skip') {
+            continue;
+        }
+        const [leftPx, rightPx] = (0, util_1.featureSpanPx)(feature, region, bpPerPx);
+        const snpinfo = feature.get('snpinfo');
+        const w = Math.max(rightPx - leftPx, 1);
+        const score0 = feature.get('score');
+        if (drawingModifications) {
+            let curr = 0;
+            const refbase = (_b = snpinfo.refbase) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+            const { nonmods, mods, snps, ref } = snpinfo;
+            for (const m of Object.keys(nonmods).sort().reverse()) {
+                const mod = visibleModifications[m.replace('nonmod_', '')] ||
+                    visibleModifications[m.replace('mod_', '')];
+                if (!mod) {
+                    console.warn(`${m} not known yet`);
+                    continue;
+                }
+                if (isolatedModification && mod.type !== isolatedModification) {
+                    continue;
+                }
+                const cmp = complementBase[mod.base];
+                const detectable = mod.base === 'N'
+                    ? score0
+                    : (((_c = snps[mod.base]) === null || _c === void 0 ? void 0 : _c.entryDepth) || 0) +
+                        (((_d = snps[cmp]) === null || _d === void 0 ? void 0 : _d.entryDepth) || 0) +
+                        (refbase === mod.base ? ref['1'] : 0) +
+                        (refbase === cmp ? ref['-1'] : 0);
+                const modifiable = mod.base === 'N'
+                    ? score0
+                    : (((_e = snps[mod.base]) === null || _e === void 0 ? void 0 : _e.entryDepth) || 0) +
+                        (((_f = snps[cmp]) === null || _f === void 0 ? void 0 : _f.entryDepth) || 0) +
+                        (refbase === mod.base ? ref.entryDepth : 0) +
+                        (refbase === cmp ? ref.entryDepth : 0);
+                const { entryDepth, avgProbability = 0 } = snpinfo.nonmods[m];
+                const modFraction = (modifiable / score0) * (entryDepth / detectable);
+                const nonModColor = 'blue';
+                const c = (0, util_2.alphaColor)(nonModColor, avgProbability);
+                const height = toHeight(score0);
+                const bottom = toY(score0) + height;
+                ctx.fillStyle = c;
+                ctx.fillRect(Math.round(leftPx), bottom - (curr + modFraction * height), w, modFraction * height);
+                curr += modFraction * height;
+            }
+            for (const m of Object.keys(mods).sort().reverse()) {
+                const mod = visibleModifications[m.replace('mod_', '')];
+                if (!mod) {
+                    console.warn(`${m} not known yet`);
+                    continue;
+                }
+                if (isolatedModification && mod.type !== isolatedModification) {
+                    continue;
+                }
+                const cmp = complementBase[mod.base];
+                const detectable = mod.base === 'N'
+                    ? score0
+                    : (((_g = snps[mod.base]) === null || _g === void 0 ? void 0 : _g.entryDepth) || 0) +
+                        (((_h = snps[cmp]) === null || _h === void 0 ? void 0 : _h.entryDepth) || 0) +
+                        (refbase === mod.base ? ref['1'] : 0) +
+                        (refbase === cmp ? ref['-1'] : 0);
+                const modifiable = mod.base === 'N'
+                    ? score0
+                    : (((_j = snps[mod.base]) === null || _j === void 0 ? void 0 : _j.entryDepth) || 0) +
+                        (((_k = snps[cmp]) === null || _k === void 0 ? void 0 : _k.entryDepth) || 0) +
+                        (refbase === mod.base ? ref.entryDepth : 0) +
+                        (refbase === cmp ? ref.entryDepth : 0);
+                const { entryDepth, avgProbability = 0 } = mods[m];
+                const modFraction = (modifiable / score0) * (entryDepth / detectable);
+                const baseColor = mod.color || 'black';
+                const c = (0, util_2.alphaColor)(baseColor, avgProbability);
+                const height = toHeight(score0);
+                const bottom = toY(score0) + height;
+                ctx.fillStyle = c;
+                ctx.fillRect(Math.round(leftPx), bottom - (curr + modFraction * height), w, modFraction * height);
+                curr += modFraction * height;
+            }
+        }
+        else if (drawingMethylation) {
+            const { depth, nonmods, mods } = snpinfo;
+            let curr = 0;
+            for (const base of Object.keys(mods).sort().reverse()) {
+                const { entryDepth } = mods[base];
+                const height = toHeight(score0);
+                const bottom = toY(score0) + height;
+                ctx.fillStyle = colorForBase[base] || 'black';
+                ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                curr += entryDepth;
+            }
+            for (const base of Object.keys(nonmods).sort().reverse()) {
+                const { entryDepth } = nonmods[base];
+                const height = toHeight(score0);
+                const bottom = toY(score0) + height;
+                ctx.fillStyle = colorForBase[base] || 'black';
+                ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                curr += entryDepth;
+            }
+        }
+        else {
+            const { depth, snps } = snpinfo;
+            let curr = 0;
+            for (const base of Object.keys(snps).sort().reverse()) {
+                const { entryDepth } = snps[base];
+                const height = toHeight(score0);
+                const bottom = toY(score0) + height;
+                ctx.fillStyle = colorForBase[base] || 'black';
+                ctx.fillRect(Math.round(leftPx), bottom - ((entryDepth + curr) / depth) * height, w, (entryDepth / depth) * height);
+                curr += entryDepth;
+            }
+        }
+        const interbaseEvents = Object.keys(snpinfo.noncov);
+        if (showInterbaseCounts) {
+            let curr = 0;
+            for (const base of interbaseEvents) {
+                const { entryDepth } = snpinfo.noncov[base];
+                const r = 0.6;
+                ctx.fillStyle = colorForBase[base];
+                ctx.fillRect(leftPx - r + extraHorizontallyFlippedOffset, INTERBASE_INDICATOR_HEIGHT + toHeight2(curr), r * 2, toHeight2(entryDepth));
+                curr += entryDepth;
+            }
+        }
+        if (showInterbaseIndicators) {
+            let accum = 0;
+            let max = 0;
+            let maxBase = '';
+            for (const base of interbaseEvents) {
+                const { entryDepth } = snpinfo.noncov[base];
+                accum += entryDepth;
+                if (entryDepth > max) {
+                    max = entryDepth;
+                    maxBase = base;
+                }
+            }
+            const indicatorComparatorScore = Math.max(score0, prevTotal);
+            if (accum > indicatorComparatorScore * indicatorThreshold &&
+                indicatorComparatorScore > MINIMUM_INTERBASE_INDICATOR_READ_DEPTH) {
+                ctx.fillStyle = colorForBase[maxBase];
+                ctx.beginPath();
+                const l = leftPx + extraHorizontallyFlippedOffset;
+                ctx.moveTo(l - INTERBASE_INDICATOR_WIDTH / 2, 0);
+                ctx.lineTo(l + INTERBASE_INDICATOR_WIDTH / 2, 0);
+                ctx.lineTo(l, INTERBASE_INDICATOR_HEIGHT);
+                ctx.fill();
+            }
+        }
+        prevTotal = score0;
+    }
+    if (showArcs) {
+        for (const f of feats) {
+            if (f.get('type') !== 'skip') {
+                continue;
+            }
+            const s = f.get('start');
+            const e = f.get('end');
+            const [left, right] = (0, util_1.bpSpanPx)(s, e, region, bpPerPx);
+            ctx.beginPath();
+            const effectiveStrand = f.get('effectiveStrand');
+            const pos = 'rgba(255,200,200,0.7)';
+            const neg = 'rgba(200,200,255,0.7)';
+            const neutral = 'rgba(200,200,200,0.7)';
+            if (effectiveStrand === 1) {
+                ctx.strokeStyle = pos;
+            }
+            else if (effectiveStrand === -1) {
+                ctx.strokeStyle = neg;
+            }
+            else {
+                ctx.strokeStyle = neutral;
+            }
+            ctx.lineWidth = Math.log(f.get('score') + 1);
+            ctx.moveTo(left, height - offset * 2);
+            ctx.bezierCurveTo(left, 0, right, 0, right, height - offset * 2);
+            ctx.stroke();
+        }
+    }
+    if (displayCrossHatches) {
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = 'rgba(140,140,140,0.8)';
+        for (const tick of ticks.values) {
+            ctx.beginPath();
+            ctx.moveTo(0, Math.round(toY(tick)));
+            ctx.lineTo(width, Math.round(toY(tick)));
+            ctx.stroke();
+        }
+    }
+}

package/dist/SNPCoverageRenderer/types.d.ts

@@ -0,0 +1,19 @@
+import type { ColorBy, ModificationTypeWithColor } from '../shared/types';
+import type { RenderArgsDeserialized as FeatureRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
+import type { Feature } from '@jbrowse/core/util';
+import type { ScaleOpts } from '@jbrowse/plugin-wiggle';
+export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
+    bpPerPx: number;
+    height: number;
+    highResolutionScaling: number;
+    scaleOpts: ScaleOpts;
+}
+export interface RenderArgsDeserializedWithFeatures extends RenderArgsDeserialized {
+    features: Map<string, Feature>;
+    ticks: {
+        values: number[];
+    };
+    displayCrossHatches: boolean;
+    visibleModifications?: Record<string, ModificationTypeWithColor>;
+    colorBy: ColorBy;
+}

package/dist/SNPCoverageRenderer/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import Plugin from '@jbrowse/core/Plugin';
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default class AlignmentsPlugin extends Plugin {
     name: string;
     install(pluginManager: PluginManager): void;
 }
-export { linearPileupDisplayStateModelFactory, linearPileupDisplayConfigSchemaFactory, SharedLinearPileupDisplayMixin, } from './LinearPileupDisplay';
+export { SharedLinearPileupDisplayMixin, linearPileupDisplayConfigSchemaFactory, linearPileupDisplayStateModelFactory, } from './LinearPileupDisplay';
 export { type LinearPileupDisplayModel } from './LinearPileupDisplay/model';
 export * as MismatchParser from './MismatchParser';

package/dist/index.js

@@ -15,34 +15,44 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MismatchParser = exports.SharedLinearPileupDisplayMixin = exports.linearPileupDisplayConfigSchemaFactory = exports.linearPileupDisplayStateModelFactory = void 0;
+exports.MismatchParser = exports.linearPileupDisplayStateModelFactory = exports.linearPileupDisplayConfigSchemaFactory = exports.SharedLinearPileupDisplayMixin = void 0;
 const Plugin_1 = __importDefault(require("@jbrowse/core/Plugin"));
-const CramAdapter_1 = __importDefault(require("./CramAdapter"));
+const AlignmentsFeatureDetail_1 = __importDefault(require("./AlignmentsFeatureDetail"));
+const AlignmentsTrack_1 = __importDefault(require("./AlignmentsTrack"));
 const BamAdapter_1 = __importDefault(require("./BamAdapter"));
+const CramAdapter_1 = __importDefault(require("./CramAdapter"));
+const GuessAlignmentsTypes_1 = __importDefault(require("./GuessAlignmentsTypes"));
 const HtsgetBamAdapter_1 = __importDefault(require("./HtsgetBamAdapter"));
-const SNPCoverageAdapter_1 = __importDefault(require("./SNPCoverageAdapter"));
-const SNPCoverageRenderer_1 = __importDefault(require("./SNPCoverageRenderer"));
-const PileupRenderer_1 = __importDefault(require("./PileupRenderer"));
 const LinearAlignmentsDisplay_1 = __importDefault(require("./LinearAlignmentsDisplay"));
-const LinearSNPCoverageDisplay_1 = __importDefault(require("./LinearSNPCoverageDisplay"));
+const LinearPileupDisplay_1 = __importDefault(require("./LinearPileupDisplay"));
 const LinearReadArcsDisplay_1 = __importDefault(require("./LinearReadArcsDisplay"));
 const LinearReadCloudDisplay_1 = __importDefault(require("./LinearReadCloudDisplay"));
-const AlignmentsTrack_1 = __importDefault(require("./AlignmentsTrack"));
-const AlignmentsFeatureDetail_1 = __importDefault(require("./AlignmentsFeatureDetail"));
+const LinearSNPCoverageDisplay_1 = __importDefault(require("./LinearSNPCoverageDisplay"));
 const PileupRPC_1 = __importDefault(require("./PileupRPC"));
-const GuessAlignmentsTypes_1 = __importDefault(require("./GuessAlignmentsTypes"));
-const LinearPileupDisplay_1 = __importDefault(require("./LinearPileupDisplay"));
+const PileupRenderer_1 = __importDefault(require("./PileupRenderer"));
+const SNPCoverageAdapter_1 = __importDefault(require("./SNPCoverageAdapter"));
+const SNPCoverageRenderer_1 = __importDefault(require("./SNPCoverageRenderer"));
 class AlignmentsPlugin extends Plugin_1.default {
     constructor() {
         super(...arguments);
@@ -73,7 +83,7 @@ class AlignmentsPlugin extends Plugin_1.default {
 }
 exports.default = AlignmentsPlugin;
 var LinearPileupDisplay_2 = require("./LinearPileupDisplay");
-Object.defineProperty(exports, "linearPileupDisplayStateModelFactory", { enumerable: true, get: function () { return LinearPileupDisplay_2.linearPileupDisplayStateModelFactory; } });
-Object.defineProperty(exports, "linearPileupDisplayConfigSchemaFactory", { enumerable: true, get: function () { return LinearPileupDisplay_2.linearPileupDisplayConfigSchemaFactory; } });
 Object.defineProperty(exports, "SharedLinearPileupDisplayMixin", { enumerable: true, get: function () { return LinearPileupDisplay_2.SharedLinearPileupDisplayMixin; } });
+Object.defineProperty(exports, "linearPileupDisplayConfigSchemaFactory", { enumerable: true, get: function () { return LinearPileupDisplay_2.linearPileupDisplayConfigSchemaFactory; } });
+Object.defineProperty(exports, "linearPileupDisplayStateModelFactory", { enumerable: true, get: function () { return LinearPileupDisplay_2.linearPileupDisplayStateModelFactory; } });
 exports.MismatchParser = __importStar(require("./MismatchParser"));

package/dist/shared/afterAttach.d.ts

@@ -1,2 +1,2 @@
-import { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from 'mobx-state-tree';
 export declare function doAfterAttach<T extends IAnyStateTreeNode>(self: T, cb: (self: T, ctx: CanvasRenderingContext2D, width: number, height: number) => void): void;

package/dist/shared/afterAttach.js

@@ -27,14 +27,12 @@ function doAfterAttach(self, cb) {
         self.setLastDrawnOffsetPx(view.offsetPx);
         self.setLastDrawnBpPerPx(view.bpPerPx);
     }
-    // first autorun instantly draws if bpPerPx changes
     (0, util_2.createAutorun)(self, async () => {
         const view = (0, util_1.getContainingView)(self);
         if (view.bpPerPx !== self.lastDrawnBpPerPx) {
             draw(view);
         }
     });
-    // second autorun draws after delay 1000 e.g. if offsetPx changes
     (0, util_2.createAutorun)(self, async () => {
         const view = (0, util_1.getContainingView)(self);
         draw(view);

package/dist/shared/color.d.ts

@@ -1,4 +1,4 @@
-import { ChainStats } from './fetchChains';
+import type { ChainStats } from './fetchChains';
 export declare const fillColor: {
     color_fwd_strand_not_proper: string;
     color_rev_strand_not_proper: string;

package/dist/shared/color.js

@@ -25,12 +25,6 @@ exports.fillColor = {
     color_shortinsert: 'pink',
     color_unknown: 'grey',
 };
-// manually calculated by running
-// const color = require('color')
-// Object.fromEntries(Object.entries(fillColor).map(([key,val])=>{
-//   return [key, color(val).darken('0.3').hex()]
-// }))
-// this avoids (expensive) use of Color module at runtime
 exports.strokeColor = {
     color_fwd_strand_not_proper: '#CA6767',
     color_rev_strand_not_proper: '#7272AA',
@@ -67,8 +61,6 @@ function getPairedInsertSizeColor(f1, f2, stats) {
     }
 }
 const defaultColor = [exports.fillColor.color_unknown, exports.fillColor.color_unknown];
-// return color scheme with both insert size and orientation coloring,
-// prioritzing orientation coloring
 function getPairedInsertSizeAndOrientationColor(f1, f2, stats) {
     return (getPairedOrientationColorOrDefault(f1) ||
         getPairedInsertSizeColor(f1, f2, stats) ||

package/dist/shared/components/BaseDisplayComponent.d.ts

@@ -1,8 +1,7 @@
-import React from 'react';
-import { LinearReadCloudDisplayModel } from '../../LinearReadCloudDisplay/model';
-import { LinearReadArcsDisplayModel } from '../../LinearReadArcsDisplay/model';
+import type { LinearReadArcsDisplayModel } from '../../LinearReadArcsDisplay/model';
+import type { LinearReadCloudDisplayModel } from '../../LinearReadCloudDisplay/model';
 declare const BaseDisplayComponent: ({ model, children, }: {
     model: LinearReadArcsDisplayModel | LinearReadCloudDisplayModel;
     children?: React.ReactNode;
-}) => React.JSX.Element | null;
+}) => import("react/jsx-runtime").JSX.Element | null;
 export default BaseDisplayComponent;

package/dist/shared/components/BaseDisplayComponent.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
+const jsx_runtime_1 = require("react/jsx-runtime");
 const ui_1 = require("@jbrowse/core/ui");
-const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
-const mui_1 = require("tss-react/mui");
-const mobx_react_1 = require("mobx-react");
 const util_1 = require("@jbrowse/core/util");
+const plugin_linear_genome_view_1 = require("@jbrowse/plugin-linear-genome-view");
 const material_1 = require("@mui/material");
+const mobx_react_1 = require("mobx-react");
+const mui_1 = require("tss-react/mui");
 const useStyles = (0, mui_1.makeStyles)()(theme => ({
     loading: {
         backgroundColor: theme.palette.background.default,
@@ -23,28 +20,25 @@ const useStyles = (0, mui_1.makeStyles)()(theme => ({
         textAlign: 'center',
     },
 }));
+const BlockError = (0, mobx_react_1.observer)(function ({ model, }) {
+    const { error } = model;
+    return ((0, jsx_runtime_1.jsx)(plugin_linear_genome_view_1.BlockMsg, { message: `${error}`, severity: "error", action: (0, jsx_runtime_1.jsx)(material_1.Tooltip, { title: "Reload", children: (0, jsx_runtime_1.jsx)(material_1.Button, { "data-testid": "reload_button", onClick: () => {
+                    model.reload();
+                }, children: "Reload" }) }) }));
+});
 const BaseDisplayComponent = (0, mobx_react_1.observer)(function ({ model, children, }) {
     const { error, regionTooLarge } = model;
-    return error ? (react_1.default.createElement(plugin_linear_genome_view_1.BlockMsg, { message: `${error}`, severity: "error", action: react_1.default.createElement(material_1.Tooltip, { title: "Reload" },
-            react_1.default.createElement(material_1.Button, { "data-testid": "reload_button", onClick: () => {
-                    model.reload();
-                } }, "Reload")) })) : regionTooLarge ? (model.regionCannotBeRendered()) : (react_1.default.createElement(DataDisplay, { model: model }, children));
+    return error ? ((0, jsx_runtime_1.jsx)(BlockError, { model: model })) : regionTooLarge ? (model.regionCannotBeRendered()) : ((0, jsx_runtime_1.jsx)(DataDisplay, { model: model, children: children }));
 });
 const DataDisplay = (0, mobx_react_1.observer)(function ({ model, children, }) {
     const { drawn, loading } = model;
     const view = (0, util_1.getContainingView)(model);
     const left = (model.lastDrawnOffsetPx || 0) - view.offsetPx;
-    return (
-    // this data-testid is located here because changing props on the canvas
-    // itself is very sensitive to triggering ref invalidation
-    react_1.default.createElement("div", { "data-testid": `drawn-${drawn}` },
-        react_1.default.createElement("div", { style: { position: 'absolute', left } }, children),
-        left !== 0 || loading ? react_1.default.createElement(LoadingBar, { model: model }) : null));
+    return ((0, jsx_runtime_1.jsxs)("div", { "data-testid": `drawn-${drawn}`, children: [(0, jsx_runtime_1.jsx)("div", { style: { position: 'absolute', left }, children: children }), left !== 0 || loading ? (0, jsx_runtime_1.jsx)(LoadingBar, { model: model }) : null] }));
 });
 const LoadingBar = (0, mobx_react_1.observer)(function ({ model, }) {
     const { classes } = useStyles();
     const { message } = model;
-    return (react_1.default.createElement("div", { className: classes.loading },
-        react_1.default.createElement(ui_1.LoadingEllipses, { message: message })));
+    return ((0, jsx_runtime_1.jsx)("div", { className: classes.loading, children: (0, jsx_runtime_1.jsx)(ui_1.LoadingEllipses, { message: message }) }));
 });
 exports.default = BaseDisplayComponent;

package/dist/shared/components/FilterByTagDialog.d.ts

@@ -1,10 +1,9 @@
-import React from 'react';
-import { FilterBy } from '../types';
+import type { FilterBy } from '../types';
 declare const FilterByTagDialog: (props: {
     model: {
         filterBy: FilterBy;
         setFilterBy: (arg: FilterBy) => void;
     };
     handleClose: () => void;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default FilterByTagDialog;