@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/PileupRenderer/renderers/renderModifications.js

@@ -0,0 +1,99 @@
+import { colord } from '@jbrowse/core/util/colord';
+import { getNextRefPos } from "../../MismatchParser/index.js";
+import { getModPositions } from "../../ModificationParser/getModPositions.js";
+import { getModProbabilities } from "../../ModificationParser/getModProbabilities.js";
+import { getMaxProbModAtEachPosition } from "../../shared/getMaximumModificationAtEachPosition.js";
+import { getModificationName } from "../../shared/modificationData.js";
+import { alphaColor, buildMismatchMap } from "../../shared/util.js";
+import { getTagAlt } from "../../util.js";
+const BLUE_COLORD = colord('blue');
+export function renderModifications({ ctx, feat, region, bpPerPx, renderArgs, cigarOps, }) {
+    const items = [];
+    const coords = [];
+    const { feature, topPx, heightPx } = feat;
+    const { colorBy, visibleModifications = {} } = renderArgs;
+    const seq = feature.get('seq');
+    if (!seq) {
+        return { coords, items };
+    }
+    const start = feature.get('start');
+    const mismatchMap = buildMismatchMap(feature, start);
+    const isolatedModification = colorBy?.modifications?.isolatedModification;
+    const twoColor = colorBy?.modifications?.twoColor;
+    const modificationThreshold = colorBy?.modifications?.threshold ?? 10;
+    const thresholdFraction = modificationThreshold / 100;
+    const bottomPx = topPx + heightPx;
+    const fstrand = feature.get('strand');
+    const mm = getTagAlt(feature, 'MM', 'Mm') || '';
+    const modifications = getModPositions(mm, seq, fstrand);
+    const probabilities = getModProbabilities(feature);
+    const modsByPosition = new Map();
+    let probIndex = 0;
+    for (const { type, base, strand, positions } of modifications) {
+        for (const { ref, idx } of getNextRefPos(cigarOps, positions)) {
+            const prob = probabilities?.[probIndex + (fstrand === -1 ? positions.length - 1 - idx : idx)] || 0;
+            if (!modsByPosition.has(ref)) {
+                modsByPosition.set(ref, []);
+            }
+            modsByPosition.get(ref).push({ type, base, strand, prob });
+        }
+        probIndex += positions.length;
+    }
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const reversed = region.reversed;
+    const invBpPerPx = 1 / bpPerPx;
+    getMaxProbModAtEachPosition(feature, cigarOps)?.forEach(({ allProbs, prob, type }, pos) => {
+        const r = start + pos;
+        if (r < regionStart || r >= regionEnd) {
+            return;
+        }
+        const mod = visibleModifications[type];
+        if (!mod || (isolatedModification && mod.type !== isolatedModification)) {
+            return;
+        }
+        if (prob < thresholdFraction) {
+            return;
+        }
+        const leftPx = reversed
+            ? (regionEnd - r - 1) * invBpPerPx
+            : (r - regionStart) * invBpPerPx;
+        const rightPx = reversed
+            ? (regionEnd - r) * invBpPerPx
+            : (r + 1 - regionStart) * invBpPerPx;
+        const widthPx = rightPx - leftPx + 0.5;
+        const col = mod.color || 'black';
+        let sumProbs = 0;
+        let maxProb = 0;
+        for (let i = 0, l = allProbs.length; i < l; i++) {
+            const p = allProbs[i];
+            sumProbs += p;
+            if (p > maxProb) {
+                maxProb = p;
+            }
+        }
+        const s = 1 - sumProbs;
+        ctx.fillStyle =
+            twoColor && s > maxProb
+                ? BLUE_COLORD.alpha(s).toHslString()
+                : alphaColor(col, prob);
+        ctx.fillRect(leftPx, topPx, widthPx, heightPx);
+        const modsAtPos = modsByPosition.get(pos);
+        if (rightPx - leftPx >= 0.2 && modsAtPos) {
+            const mismatchBase = mismatchMap.get(r);
+            items.push({
+                type: 'modification',
+                info: modsAtPos
+                    .map(m => `${m.base}${m.strand}${m.type} ${getModificationName(m.type)} (${(m.prob * 100).toFixed(1)}%)`)
+                    .join('\n'),
+                modType: type,
+                probability: prob,
+                start: r,
+                mismatch: mismatchBase,
+            });
+            coords.push(leftPx, topPx, rightPx, bottomPx);
+        }
+        pos++;
+    });
+    return { coords, items };
+}

package/{dist/PileupRenderer → esm/PileupRenderer/renderers}/renderPerBaseLettering.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutFeature } from './util';
+import type { LayoutFeature } from '../util.ts';
 import type { Region } from '@jbrowse/core/util';
 export declare function renderPerBaseLettering({ ctx, feat, region, bpPerPx, colorMap, colorContrastMap, charWidth, charHeight, canvasWidth, cigarOps, }: {
     ctx: CanvasRenderingContext2D;
@@ -10,5 +10,5 @@ export declare function renderPerBaseLettering({ ctx, feat, region, bpPerPx, col
     charWidth: number;
     charHeight: number;
     canvasWidth: number;
-    cigarOps: string[];
+    cigarOps: ArrayLike<number>;
 }): void;

package/esm/PileupRenderer/renderers/renderPerBaseLettering.js

@@ -0,0 +1,59 @@
+import { CIGAR_D, CIGAR_EQ, CIGAR_I, CIGAR_M, CIGAR_N, CIGAR_S, CIGAR_X, } from "./cigarUtil.js";
+export function renderPerBaseLettering({ ctx, feat, region, bpPerPx, colorMap, colorContrastMap, charWidth, charHeight, canvasWidth, cigarOps, }) {
+    const heightLim = charHeight - 2;
+    const { feature, topPx, heightPx } = feat;
+    const seq = feature.get('seq');
+    const invBpPerPx = 1 / bpPerPx;
+    const w = invBpPerPx;
+    const start = feature.get('start');
+    let soffset = 0;
+    let roffset = 0;
+    if (!seq) {
+        return;
+    }
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const reversed = region.reversed;
+    for (let i = 0, l = cigarOps.length; i < l; i++) {
+        const packed = cigarOps[i];
+        const len = packed >> 4;
+        const op = packed & 0xf;
+        if (op === CIGAR_S || op === CIGAR_I) {
+            soffset += len;
+        }
+        else if (op === CIGAR_D || op === CIGAR_N) {
+            roffset += len;
+        }
+        else if (op === CIGAR_M || op === CIGAR_X || op === CIGAR_EQ) {
+            const opStart = start + roffset;
+            const opEnd = opStart + len;
+            if (opStart >= regionEnd) {
+                break;
+            }
+            if (opEnd > regionStart) {
+                const visStart = Math.max(0, regionStart - opStart);
+                const visEnd = Math.min(len, regionEnd - opStart);
+                for (let m = visStart; m < visEnd; m++) {
+                    const letter = seq[soffset + m];
+                    const r = opStart + m;
+                    const leftPx = reversed
+                        ? (regionEnd - r - 1) * invBpPerPx
+                        : (r - regionStart) * invBpPerPx;
+                    ctx.fillStyle = colorMap[letter];
+                    ctx.fillRect(leftPx, topPx, w + 0.5, heightPx);
+                    if (w >= charWidth && heightPx >= heightLim) {
+                        const x = leftPx + (w - charWidth) / 2 + 1;
+                        const y = topPx + heightPx;
+                        const color = colorContrastMap[letter];
+                        if (x >= 0 && x <= canvasWidth && color) {
+                            ctx.fillStyle = color;
+                            ctx.fillText(letter, x, y);
+                        }
+                    }
+                }
+            }
+            soffset += len;
+            roffset += len;
+        }
+    }
+}

package/{dist/PileupRenderer → esm/PileupRenderer/renderers}/renderPerBaseQuality.d.ts

@@ -1,10 +1,9 @@
-import type { LayoutFeature } from './util';
+import type { LayoutFeature } from '../util.ts';
 import type { Region } from '@jbrowse/core/util';
-export declare function renderPerBaseQuality({ ctx, feat, region, bpPerPx, canvasWidth, cigarOps, }: {
+export declare function renderPerBaseQuality({ ctx, feat, region, bpPerPx, cigarOps, }: {
     ctx: CanvasRenderingContext2D;
     feat: LayoutFeature;
     region: Region;
     bpPerPx: number;
-    canvasWidth: number;
-    cigarOps: string[];
+    cigarOps: ArrayLike<number>;
 }): void;

package/esm/PileupRenderer/renderers/renderPerBaseQuality.js

@@ -0,0 +1,48 @@
+import { CIGAR_D, CIGAR_EQ, CIGAR_I, CIGAR_M, CIGAR_N, CIGAR_S, CIGAR_X, } from "./cigarUtil.js";
+const qualityColors = Array.from({ length: 256 }, (_, score) => `hsl(${score === 255 ? 150 : score * 1.5},55%,50%)`);
+export function renderPerBaseQuality({ ctx, feat, region, bpPerPx, cigarOps, }) {
+    const { feature, topPx, heightPx } = feat;
+    const qual = feature.get('qual') || '';
+    const scores = qual.split(' ').map(val => +val);
+    const invBpPerPx = 1 / bpPerPx;
+    const w = invBpPerPx;
+    const start = feature.get('start');
+    let soffset = 0;
+    let roffset = 0;
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const reversed = region.reversed;
+    for (let i = 0, l = cigarOps.length; i < l; i++) {
+        const packed = cigarOps[i];
+        const len = packed >> 4;
+        const opIdx = packed & 0xf;
+        if (opIdx === CIGAR_S || opIdx === CIGAR_I) {
+            soffset += len;
+        }
+        else if (opIdx === CIGAR_D || opIdx === CIGAR_N) {
+            roffset += len;
+        }
+        else if (opIdx === CIGAR_M || opIdx === CIGAR_X || opIdx === CIGAR_EQ) {
+            const opStart = start + roffset;
+            const opEnd = opStart + len;
+            if (opStart >= regionEnd) {
+                break;
+            }
+            if (opEnd > regionStart) {
+                const visStart = Math.max(0, regionStart - opStart);
+                const visEnd = Math.min(len, regionEnd - opStart);
+                for (let m = visStart; m < visEnd; m++) {
+                    const score = scores[soffset + m];
+                    const refPos = opStart + m;
+                    const leftPx = reversed
+                        ? (regionEnd - refPos - 1) * invBpPerPx
+                        : (refPos - regionStart) * invBpPerPx;
+                    ctx.fillStyle = qualityColors[score] || qualityColors[0];
+                    ctx.fillRect(leftPx, topPx, w + 0.5, heightPx);
+                }
+            }
+            soffset += len;
+            roffset += len;
+        }
+    }
+}

package/{dist/PileupRenderer → esm/PileupRenderer/renderers}/renderSoftClipping.d.ts

@@ -1,5 +1,5 @@
-import type { ProcessedRenderArgs } from './types';
-import type { LayoutFeature } from './util';
+import type { ProcessedRenderArgs } from '../types.ts';
+import type { LayoutFeature } from '../util.ts';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { Theme } from '@mui/material';
 export declare function renderSoftClipping({ ctx, feat, renderArgs, config, theme, colorMap, canvasWidth, }: {

package/esm/PileupRenderer/renderers/renderSoftClipping.js

@@ -0,0 +1,75 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { CIGAR_D, CIGAR_EQ, CIGAR_I, CIGAR_M, CIGAR_N, CIGAR_S, CIGAR_X, getCigarOps, } from "./cigarUtil.js";
+import { getCharWidthHeight } from "../../shared/util.js";
+export function renderSoftClipping({ ctx, feat, renderArgs, config, theme, colorMap, canvasWidth, }) {
+    const { feature, topPx, heightPx } = feat;
+    const { regions, bpPerPx } = renderArgs;
+    const region = regions[0];
+    const minFeatWidth = readConfObject(config, 'minSubfeatureWidth');
+    const mismatches = feature.get('mismatches');
+    const seq = feature.get('seq');
+    const { charWidth, charHeight } = getCharWidthHeight();
+    if (!(seq && mismatches)) {
+        return;
+    }
+    const heightLim = charHeight - 2;
+    let seqOffset = 0;
+    let refOffset = 0;
+    const CIGAR = feature.get('NUMERIC_CIGAR') || feature.get('CIGAR');
+    const ops = getCigarOps(CIGAR);
+    const featStart = feature.get('start');
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const reversed = region.reversed;
+    const invBpPerPx = 1 / bpPerPx;
+    for (let i = 0, l = ops.length; i < l; i++) {
+        const packed = ops[i];
+        const len = packed >> 4;
+        const op = packed & 0xf;
+        if (op === CIGAR_S) {
+            const clipStart = featStart - (i === 0 ? len : 0) + refOffset;
+            const clipEnd = clipStart + len;
+            if (clipEnd > regionStart && clipStart < regionEnd) {
+                const visStart = Math.max(0, regionStart - clipStart);
+                const visEnd = Math.min(len, regionEnd - clipStart);
+                for (let k = visStart; k < visEnd; k++) {
+                    const base = seq[seqOffset + k];
+                    const s0 = clipStart + k;
+                    const leftPx = reversed
+                        ? (regionEnd - s0 - 1) * invBpPerPx
+                        : (s0 - regionStart) * invBpPerPx;
+                    const rightPx = reversed
+                        ? (regionEnd - s0) * invBpPerPx
+                        : (s0 + 1 - regionStart) * invBpPerPx;
+                    const widthPx = Math.max(minFeatWidth, rightPx - leftPx);
+                    const baseColor = colorMap[base] || '#000000';
+                    ctx.fillStyle = baseColor;
+                    ctx.fillRect(leftPx, topPx, widthPx, heightPx);
+                    if (widthPx >= charWidth && heightPx >= heightLim) {
+                        const x = leftPx + (widthPx - charWidth) / 2 + 1;
+                        const y = topPx + heightPx;
+                        const color = theme.palette.getContrastText(baseColor);
+                        if (x >= 0 && x <= canvasWidth && color) {
+                            ctx.fillStyle = color;
+                            ctx.fillText(base, x, y);
+                        }
+                    }
+                }
+            }
+            seqOffset += len;
+        }
+        else if (op === CIGAR_N) {
+            refOffset += len;
+        }
+        else if (op === CIGAR_M || op === CIGAR_EQ || op === CIGAR_X) {
+            refOffset += len;
+            seqOffset += len;
+        }
+        else if (op === CIGAR_D) {
+            refOffset += len;
+        }
+        else if (op === CIGAR_I) {
+            seqOffset += len;
+        }
+    }
+}

package/esm/PileupRenderer/sortUtil.d.ts

@@ -1,3 +1,3 @@
-import type { SortedBy } from '../shared/types';
+import type { SortedBy } from '../shared/types.ts';
 import type { Feature } from '@jbrowse/core/util';
-export declare const sortFeature: (features: Map<string, Feature>, sortedBy: SortedBy) => Map<string, Feature>;
+export declare function sortFeature(features: Map<string, Feature>, sortedBy: SortedBy): Map<string, Feature>;

package/esm/PileupRenderer/sortUtil.js

@@ -1,21 +1,23 @@
 import { doesIntersect2 } from '@jbrowse/core/util';
-export const sortFeature = (features, sortedBy) => {
-    const featureArray = Array.from(features.values());
+export function sortFeature(features, sortedBy) {
     const featuresInCenterLine = [];
     const featuresOutsideCenter = [];
     const { pos, type } = sortedBy;
-    for (const innerArray of featureArray) {
-        const feature = innerArray;
+    let firstFeature;
+    for (const feature of features.values()) {
+        if (!firstFeature) {
+            firstFeature = feature;
+        }
         const start = feature.get('start');
         const end = feature.get('end');
         if (doesIntersect2(pos - 1, pos, start, end)) {
-            featuresInCenterLine.push(innerArray);
+            featuresInCenterLine.push(feature);
         }
         else {
-            featuresOutsideCenter.push(innerArray);
+            featuresOutsideCenter.push(feature);
         }
     }
-    const isCram = featureArray.length ? featureArray[0].get('tags') : false;
+    const isCram = firstFeature ? firstFeature.get('tags') : false;
     switch (type) {
         case 'Start location': {
             featuresInCenterLine.sort((a, b) => a.get('start') - b.get('start'));
@@ -37,30 +39,36 @@ export const sortFeature = (features, sortedBy) => {
             break;
         }
         case 'Base pair': {
-            const baseSortArray = [];
+            const baseMap = new Map();
             for (const feature of featuresInCenterLine) {
                 const mismatches = feature.get('mismatches');
+                const start = feature.get('start');
                 for (const m of mismatches) {
-                    const start = feature.get('start');
                     const offset = start + m.start + 1;
                     const consuming = m.type === 'insertion' || m.type === 'softclip';
                     const len = consuming ? 0 : m.length;
                     if (pos >= offset && pos < offset + len) {
-                        baseSortArray.push([feature.id(), m]);
+                        baseMap.set(feature.id(), m);
                     }
                 }
             }
-            const baseMap = new Map(baseSortArray);
             featuresInCenterLine.sort((a, b) => {
                 const aMismatch = baseMap.get(a.id());
                 const bMismatch = baseMap.get(b.id());
-                const acode = bMismatch === null || bMismatch === void 0 ? void 0 : bMismatch.base.toUpperCase();
-                const bcode = aMismatch === null || aMismatch === void 0 ? void 0 : aMismatch.base.toUpperCase();
+                const acode = aMismatch?.type === 'mismatch'
+                    ? aMismatch.base.toUpperCase()
+                    : aMismatch?.type === 'deletion'
+                        ? '*'
+                        : undefined;
+                const bcode = bMismatch?.type === 'mismatch'
+                    ? bMismatch.base.toUpperCase()
+                    : bMismatch?.type === 'deletion'
+                        ? '*'
+                        : undefined;
                 return acode === bcode && acode === '*'
-                    ?
-                        aMismatch.length - bMismatch.length
-                    : (acode ? acode.charCodeAt(0) : 0) -
-                        (bcode ? bcode.charCodeAt(0) : 0);
+                    ? (bMismatch?.length ?? 0) - (aMismatch?.length ?? 0)
+                    : (bcode ? bcode.charCodeAt(0) : 0) -
+                        (acode ? acode.charCodeAt(0) : 0);
             });
             break;
         }
@@ -69,8 +77,12 @@ export const sortFeature = (features, sortedBy) => {
             break;
         }
     }
-    return new Map([...featuresInCenterLine, ...featuresOutsideCenter].map(feature => [
-        feature.id(),
-        feature,
-    ]));
-};
+    const result = new Map();
+    for (const feature of featuresInCenterLine) {
+        result.set(feature.id(), feature);
+    }
+    for (const feature of featuresOutsideCenter) {
+        result.set(feature.id(), feature);
+    }
+    return result;
+}

package/esm/PileupRenderer/types.d.ts

@@ -1,4 +1,4 @@
-import type { ColorBy, ModificationTypeWithColor, SortedBy } from '../shared/types';
+import type { ColorBy, ModificationTypeWithColor, SortedBy } from '../shared/types.ts';
 import type { RenderArgsDeserialized as BoxRenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType';
 import type { Feature } from '@jbrowse/core/util';
 import type { BaseLayout } from '@jbrowse/core/util/layouts/BaseLayout';
@@ -7,6 +7,37 @@ export interface LayoutFeature {
     topPx: number;
     feature: Feature;
 }
+export type FlatbushItem = {
+    type: 'mismatch';
+    base: string;
+    start: number;
+} | {
+    type: 'insertion';
+    length: number;
+    sequence?: string;
+    start: number;
+} | {
+    type: 'deletion';
+    length: number;
+    start: number;
+} | {
+    type: 'softclip';
+    length: number;
+    start: number;
+} | {
+    type: 'hardclip';
+    length: number;
+    start: number;
+} | {
+    type: 'modification';
+    info: string;
+    modType: string;
+    probability: number;
+    start: number;
+    mismatch?: string;
+};
+export declare function getFlatbushItemLabel(item: FlatbushItem): string;
+export declare function flatbushItemToFeatureData(item: FlatbushItem, refName: string, sourceRead?: string): Record<string, unknown>;
 export interface RenderArgsDeserialized extends BoxRenderArgsDeserialized {
     colorBy?: ColorBy;
     colorTagMap?: Record<string, string>;

package/esm/PileupRenderer/types.js

@@ -1 +1,71 @@
-export {};
+const LARGE_INSERTION_THRESHOLD = 10;
+export function getFlatbushItemLabel(item) {
+    switch (item.type) {
+        case 'insertion':
+            if (item.sequence && item.sequence.length <= LARGE_INSERTION_THRESHOLD) {
+                return `Insertion: ${item.sequence}`;
+            }
+            return `Insertion: ${item.length}bp`;
+        case 'deletion':
+            return `Deletion: ${item.length}bp`;
+        case 'softclip':
+            return `Soft clip: ${item.length}bp`;
+        case 'hardclip':
+            return `Hard clip: ${item.length}bp`;
+        case 'modification': {
+            const mismatchInfo = item.mismatch ? `\nMismatch: ${item.mismatch}` : '';
+            return item.info + mismatchInfo;
+        }
+        case 'mismatch':
+            return `Mismatch: ${item.base}`;
+    }
+}
+export function flatbushItemToFeatureData(item, refName, sourceRead) {
+    const base = {
+        uniqueId: `${item.type}-${item.start}`,
+        type: item.type,
+        refName,
+        sourceRead,
+    };
+    switch (item.type) {
+        case 'insertion':
+            return {
+                ...base,
+                start: item.start,
+                end: item.start + 1,
+                ...(item.sequence ? { sequence: item.sequence } : {}),
+                insertionLength: item.length,
+            };
+        case 'deletion':
+            return {
+                ...base,
+                start: item.start,
+                end: item.start + item.length,
+            };
+        case 'softclip':
+        case 'hardclip':
+            return {
+                ...base,
+                start: item.start,
+                end: item.start + 1,
+                clipLength: item.length,
+            };
+        case 'modification':
+            return {
+                ...base,
+                start: item.start,
+                end: item.start + 1,
+                info: item.info,
+                modType: item.modType,
+                probability: item.probability.toFixed(3),
+                ...(item.mismatch ? { mismatch: item.mismatch } : {}),
+            };
+        case 'mismatch':
+            return {
+                ...base,
+                start: item.start,
+                end: item.start + 1,
+                base: item.base,
+            };
+    }
+}

package/esm/PileupRenderer/util.d.ts

@@ -1,28 +1,7 @@
 import type { Feature } from '@jbrowse/core/util';
-import type { Theme } from '@mui/material';
-export declare function fillRect(ctx: CanvasRenderingContext2D, l: number, t: number, w: number, h: number, cw: number, color?: string): void;
-export declare function getColorBaseMap(theme: Theme): {
-    A: string;
-    C: string;
-    G: string;
-    T: string;
-    deletion: string;
-    insertion: string;
-    hardclip: string;
-    softclip: string;
-    skip: string;
-};
-export declare function getContrastBaseMap(theme: Theme): {
-    [k: string]: string;
-};
-export declare function shouldDrawSNPsMuted(type?: string): boolean;
-export declare function shouldDrawIndels(): boolean;
 export interface LayoutFeature {
     heightPx: number;
     topPx: number;
     feature: Feature;
 }
-export declare function getCharWidthHeight(): {
-    charWidth: number;
-    charHeight: number;
-};
+export declare function measureTextSmallNumber(n: number, fontSize?: number): number;

package/esm/PileupRenderer/util.js

@@ -1,41 +1,15 @@
 import { measureText } from '@jbrowse/core/util';
-export function fillRect(ctx, l, t, w, h, cw, color) {
-    if (l + w < 0 || l > cw) {
-        return;
+const smallNumberWidthCache10 = new Map();
+const smallNumberWidthCache = new Map();
+export function measureTextSmallNumber(n, fontSize) {
+    const cache = fontSize === 10 ? smallNumberWidthCache10 : smallNumberWidthCache;
+    if (n >= 0 && n < 100) {
+        let width = cache.get(n);
+        if (width === undefined) {
+            width = measureText(String(n), fontSize);
+            cache.set(n, width);
+        }
+        return width;
     }
-    if (color) {
-        ctx.fillStyle = color;
-    }
-    ctx.fillRect(l, t, w, h);
-}
-export function getColorBaseMap(theme) {
-    const { skip, deletion, insertion, hardclip, softclip, bases } = theme.palette;
-    return {
-        A: bases.A.main,
-        C: bases.C.main,
-        G: bases.G.main,
-        T: bases.T.main,
-        deletion,
-        insertion,
-        hardclip,
-        softclip,
-        skip,
-    };
-}
-export function getContrastBaseMap(theme) {
-    return Object.fromEntries(Object.entries(getColorBaseMap(theme)).map(([key, value]) => [
-        key,
-        theme.palette.getContrastText(value),
-    ]));
-}
-export function shouldDrawSNPsMuted(type) {
-    return ['methylation', 'modifications'].includes(type || '');
-}
-export function shouldDrawIndels() {
-    return true;
-}
-export function getCharWidthHeight() {
-    const charWidth = measureText('A');
-    const charHeight = measureText('M') - 2;
-    return { charWidth, charHeight };
+    return measureText(String(n), fontSize);
 }

package/esm/RenderLinearReadArcsDisplayRPC/RenderLinearReadArcsDisplay.d.ts

@@ -0,0 +1,34 @@
+import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
+import type { ColorBy } from '../shared/types.ts';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Base1DViewModel } from '@jbrowse/core/util/Base1DViewModel';
+import type { ThemeOptions } from '@mui/material';
+export interface RenderLinearReadArcsDisplayArgs {
+    sessionId: string;
+    view: Base1DViewModel;
+    adapterConfig: AnyConfigurationModel;
+    sequenceAdapter?: Record<string, unknown>;
+    config: AnyConfigurationModel;
+    theme: ThemeOptions;
+    filterBy: Record<string, unknown>;
+    colorBy: ColorBy;
+    drawInter: boolean;
+    drawLongRange: boolean;
+    lineWidth: number;
+    jitter: number;
+    height: number;
+    highResolutionScaling?: number;
+    exportSVG?: {
+        rasterizeLayers?: boolean;
+        scale?: number;
+    };
+    statusCallback?: (status: string) => void;
+    stopToken?: string;
+}
+export default class RenderLinearReadArcsDisplay extends RpcMethodType {
+    name: string;
+    deserializeArguments(args: any, _rpcDriver: string): any;
+    renameRegionsIfNeeded(args: RenderLinearReadArcsDisplayArgs): Promise<RenderLinearReadArcsDisplayArgs>;
+    serializeArguments(args: Record<string, unknown>, rpcDriver: string): Promise<Record<string, unknown>>;
+    execute(args: Record<string, unknown>, rpcDriver: string): Promise<import("librpc-web-mod").RpcResult>;
+}