@jbrowse/plugin-alignments 3.7.0 → 4.0.0

package/esm/SNPCoverageAdapter/generateCoverageBinsPrefixSum.js

@@ -0,0 +1,438 @@
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+import { processDepthPrefixSum } from "./processDepthPrefixSum.js";
+import { processModifications } from "./processModifications.js";
+import { processReferenceCpGs } from "./processReferenceCpGs.js";
+import { isInterbase, mismatchLen } from "./util.js";
+import { CHAR_FROM_CODE } from "../PileupRenderer/renderers/cigarUtil.js";
+import { DELSKIP_MASK, INSERTION_TYPE, MISMATCH_MAP, MISMATCH_REV_MAP, SKIP_TYPE, } from "../shared/forEachMismatchTypes.js";
+export function finalizeLazyBin(bin) {
+    bin.snps ??= {};
+    bin.mods ??= {};
+    bin.nonmods ??= {};
+    bin.delskips ??= {};
+    bin.noncov ??= {};
+    return bin;
+}
+const MAX_REGION_SIZE = 1_000_000;
+const deletionChanges = new Int32Array(MAX_REGION_SIZE + 1);
+function finalizeBinEntry(entry) {
+    const { probabilityTotal, probabilityCount, lengthTotal, lengthCount } = entry;
+    if (probabilityCount) {
+        entry.avgProbability = probabilityTotal / probabilityCount;
+    }
+    if (lengthCount) {
+        entry.avgLength = lengthTotal / lengthCount;
+        entry.minLength = entry.lengthMin;
+        entry.maxLength = entry.lengthMax;
+    }
+    if (entry.sequenceCounts?.size) {
+        let maxCount = 0;
+        let topSeq;
+        for (const [seq, count] of entry.sequenceCounts) {
+            if (count > maxCount) {
+                maxCount = count;
+                topSeq = seq;
+            }
+        }
+        entry.topSequence = topSeq;
+        entry.sequenceCounts = undefined;
+    }
+}
+export async function generateCoverageBinsPrefixSum({ fetchSequence, features, region, opts, }) {
+    const { stopToken, colorBy, statsEstimationMode } = opts;
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const regionSize = regionEnd - regionStart;
+    checkStopToken(stopToken);
+    const depthSoA = processDepthPrefixSum(features, region);
+    if (statsEstimationMode) {
+        const bins = [];
+        for (let i = 0; i < regionSize; i++) {
+            const depth = depthSoA.depth[i];
+            if (depth === 0) {
+                continue;
+            }
+            bins[i] = {
+                depth,
+                readsCounted: depth,
+                ref: {
+                    entryDepth: depth,
+                    '-1': depthSoA.strandMinus[i],
+                    '0': 0,
+                    '1': depthSoA.strandPlus[i],
+                    probabilityTotal: 0,
+                    probabilityCount: 0,
+                    lengthTotal: 0,
+                    lengthCount: 0,
+                    lengthMin: Infinity,
+                    lengthMax: -Infinity,
+                },
+            };
+        }
+        return { bins, regionStart, skipmap: {} };
+    }
+    checkStopToken(stopToken);
+    deletionChanges.fill(0, 0, regionSize + 1);
+    const snpEvents = [];
+    const noncovEvents = [];
+    const skipmap = {};
+    for (let i = 0, l = features.length; i < l; i++) {
+        processFeature(region, features[i], skipmap, noncovEvents, snpEvents);
+    }
+    const deletionDepth = new Int32Array(regionSize);
+    let dd = 0;
+    for (let i = 0; i < regionSize; i++) {
+        dd += deletionChanges[i];
+        deletionDepth[i] = dd;
+    }
+    let regionSequence;
+    const modBins = [];
+    const start2 = Math.max(0, regionStart - 1);
+    const diff = regionStart - start2;
+    if (colorBy?.type === 'modifications' && fetchSequence) {
+        checkStopToken(stopToken);
+        regionSequence =
+            (await fetchSequence({
+                ...region,
+                start: start2,
+                end: regionEnd + 1,
+            })) || '';
+        const slicedSequence = regionSequence.slice(diff);
+        for (const feature of features) {
+            processModifications({
+                feature,
+                colorBy,
+                bins: modBins,
+                region,
+                regionSequence: slicedSequence,
+            });
+        }
+    }
+    else if (colorBy?.type === 'methylation' && fetchSequence) {
+        checkStopToken(stopToken);
+        regionSequence ??=
+            (await fetchSequence({
+                ...region,
+                start: start2,
+                end: regionEnd + 1,
+            })) || '';
+        for (const feature of features) {
+            processReferenceCpGs({
+                feature,
+                bins: modBins,
+                region,
+                regionSequence,
+            });
+        }
+    }
+    checkStopToken(stopToken);
+    const bins = [];
+    for (let i = 0; i < regionSize; i++) {
+        const depth = depthSoA.depth[i];
+        const delDepth = deletionDepth[i];
+        if (depth === 0 && delDepth === 0) {
+            continue;
+        }
+        bins[i] = {
+            depth: depth - delDepth,
+            readsCounted: depth,
+            ref: {
+                entryDepth: depth,
+                '-1': depthSoA.strandMinus[i],
+                '0': 0,
+                '1': depthSoA.strandPlus[i],
+                probabilityTotal: 0,
+                probabilityCount: 0,
+                lengthTotal: 0,
+                lengthCount: 0,
+                lengthMin: Infinity,
+                lengthMax: -Infinity,
+            },
+            delskips: delDepth > 0 ? { deletion: createDeletionEntry(delDepth) } : undefined,
+        };
+    }
+    for (let i = 0, l = snpEvents.length; i < l; i++) {
+        const evt = snpEvents[i];
+        const pos = evt.pos;
+        const entry = evt.entry;
+        let bin = bins[pos];
+        if (!bin) {
+            bin = {
+                depth: 0,
+                readsCounted: 0,
+                ref: {
+                    entryDepth: 0,
+                    '-1': 0,
+                    '0': 0,
+                    '1': 0,
+                    probabilityTotal: 0,
+                    probabilityCount: 0,
+                    lengthTotal: 0,
+                    lengthCount: 0,
+                    lengthMin: Infinity,
+                    lengthMax: -Infinity,
+                },
+            };
+            bins[pos] = bin;
+        }
+        const base = entry.base;
+        const strand = entry.strand;
+        const snps = (bin.snps ??= {});
+        let snpEntry = snps[base];
+        if (!snpEntry) {
+            snpEntry = {
+                entryDepth: 0,
+                '-1': 0,
+                '0': 0,
+                '1': 0,
+                probabilityTotal: 0,
+                probabilityCount: 0,
+                lengthTotal: 0,
+                lengthCount: 0,
+                lengthMin: Infinity,
+                lengthMax: -Infinity,
+            };
+            snps[base] = snpEntry;
+        }
+        snpEntry.entryDepth++;
+        snpEntry[strand]++;
+        bin.ref.entryDepth--;
+        bin.ref[strand]--;
+        if (entry.altbase) {
+            bin.refbase = entry.altbase;
+        }
+    }
+    for (let i = 0, l = noncovEvents.length; i < l; i++) {
+        const evt = noncovEvents[i];
+        const pos = evt.pos;
+        const entry = evt.entry;
+        let bin = bins[pos];
+        if (!bin) {
+            bin = {
+                depth: 0,
+                readsCounted: 0,
+                ref: {
+                    entryDepth: 0,
+                    '-1': 0,
+                    '0': 0,
+                    '1': 0,
+                    probabilityTotal: 0,
+                    probabilityCount: 0,
+                    lengthTotal: 0,
+                    lengthCount: 0,
+                    lengthMin: Infinity,
+                    lengthMax: -Infinity,
+                },
+            };
+            bins[pos] = bin;
+        }
+        const strand = entry.strand;
+        const type = entry.type;
+        const length = entry.length;
+        const noncov = (bin.noncov ??= {});
+        let noncovEntry = noncov[type];
+        if (!noncovEntry) {
+            noncovEntry = {
+                entryDepth: 0,
+                '-1': 0,
+                '0': 0,
+                '1': 0,
+                probabilityTotal: 0,
+                probabilityCount: 0,
+                lengthTotal: 0,
+                lengthCount: 0,
+                lengthMin: Infinity,
+                lengthMax: -Infinity,
+            };
+            noncov[type] = noncovEntry;
+        }
+        noncovEntry.entryDepth++;
+        noncovEntry[strand]++;
+        noncovEntry.lengthTotal += length;
+        noncovEntry.lengthCount++;
+        noncovEntry.lengthMin = Math.min(noncovEntry.lengthMin, length);
+        noncovEntry.lengthMax = Math.max(noncovEntry.lengthMax, length);
+        const seq = entry.sequence;
+        if (seq !== undefined) {
+            noncovEntry.sequenceCounts ??= new Map();
+            noncovEntry.sequenceCounts.set(seq, (noncovEntry.sequenceCounts.get(seq) ?? 0) + 1);
+        }
+    }
+    for (let i = 0, l = modBins.length; i < l; i++) {
+        const modBin = modBins[i];
+        if (modBin) {
+            const bin = bins[i];
+            if (bin) {
+                if (Object.keys(modBin.mods).length > 0) {
+                    bin.mods = Object.assign(bin.mods ?? {}, modBin.mods);
+                }
+                if (Object.keys(modBin.nonmods).length > 0) {
+                    bin.nonmods = Object.assign(bin.nonmods ?? {}, modBin.nonmods);
+                }
+                if (modBin.refbase !== undefined) {
+                    bin.refbase = modBin.refbase;
+                }
+            }
+        }
+    }
+    for (let i = 0, l = bins.length; i < l; i++) {
+        const bin = bins[i];
+        if (bin) {
+            if (bin.mods) {
+                for (const key in bin.mods) {
+                    finalizeBinEntry(bin.mods[key]);
+                }
+            }
+            if (bin.nonmods) {
+                for (const key in bin.nonmods) {
+                    finalizeBinEntry(bin.nonmods[key]);
+                }
+            }
+            if (bin.noncov) {
+                for (const key in bin.noncov) {
+                    finalizeBinEntry(bin.noncov[key]);
+                }
+            }
+        }
+    }
+    return { bins, regionStart, skipmap };
+}
+function createDeletionEntry(depth) {
+    return {
+        entryDepth: depth,
+        '-1': 0,
+        '0': 0,
+        '1': 0,
+        probabilityTotal: 0,
+        probabilityCount: 0,
+        lengthTotal: 0,
+        lengthCount: 0,
+        lengthMin: Infinity,
+        lengthMax: -Infinity,
+    };
+}
+const featureCtx = {
+    fstart: 0,
+    fstrand: 0,
+    regionStart: 0,
+    regionEnd: 0,
+    regionSize: 0,
+    feature: undefined,
+    skipmap: undefined,
+    noncovEvents: undefined,
+    snpEvents: undefined,
+};
+function mismatchHandler(type, start, refLen, base, _qual, altbase, interbaseLen) {
+    const { fstart, fstrand, regionStart, regionEnd, regionSize, feature, skipmap, noncovEvents, snpEvents, } = featureCtx;
+    const mstart = fstart + start;
+    const mlen = mismatchLen(type, refLen);
+    const mend = mstart + mlen;
+    if ((1 << type) & DELSKIP_MASK) {
+        const visStart = Math.max(mstart, regionStart) - regionStart;
+        const visEnd = Math.min(mend, regionEnd) - regionStart;
+        if (visStart < visEnd) {
+            deletionChanges[visStart]++;
+            deletionChanges[visEnd]--;
+        }
+        if (type === SKIP_TYPE) {
+            const tags = feature.get('tags');
+            const xs = tags?.XS || tags?.TS;
+            const ts = tags?.ts;
+            const effectiveStrand = xs === '+'
+                ? 1
+                : xs === '-'
+                    ? -1
+                    : (ts === '+' ? 1 : ts === '-' ? -1 : 0) * fstrand;
+            const hash = `${mstart}_${mend}_${effectiveStrand}`;
+            if (skipmap[hash] === undefined) {
+                skipmap[hash] = {
+                    feature: feature,
+                    start: mstart,
+                    end: mend,
+                    strand: fstrand,
+                    effectiveStrand,
+                    score: 0,
+                };
+            }
+            skipmap[hash].score++;
+        }
+    }
+    else if (type === INSERTION_TYPE) {
+        const epos = mstart - regionStart;
+        if (epos >= 0 && epos < regionSize) {
+            noncovEvents.push({
+                pos: epos,
+                entry: {
+                    strand: fstrand,
+                    type: 'insertion',
+                    length: interbaseLen,
+                    sequence: base,
+                },
+            });
+        }
+    }
+    else if (isInterbase(type)) {
+        const epos = mstart - regionStart;
+        if (epos >= 0 && epos < regionSize) {
+            noncovEvents.push({
+                pos: epos,
+                entry: {
+                    strand: fstrand,
+                    type: MISMATCH_MAP[type],
+                    length: interbaseLen,
+                },
+            });
+        }
+    }
+    else {
+        const epos = mstart - regionStart;
+        if (epos >= 0 && epos < regionSize) {
+            snpEvents.push({
+                pos: epos,
+                entry: {
+                    base,
+                    strand: fstrand,
+                    altbase: CHAR_FROM_CODE[altbase],
+                },
+            });
+        }
+    }
+}
+function processFeature(region, feature, skipmap, noncovEvents, snpEvents) {
+    featureCtx.fstart = feature.get('start');
+    featureCtx.fstrand = feature.get('strand');
+    featureCtx.regionStart = region.start;
+    featureCtx.regionEnd = region.end;
+    featureCtx.regionSize = region.end - region.start;
+    featureCtx.feature = feature;
+    featureCtx.skipmap = skipmap;
+    featureCtx.noncovEvents = noncovEvents;
+    featureCtx.snpEvents = snpEvents;
+    if ('forEachMismatch' in feature) {
+        feature.forEachMismatch(mismatchHandler);
+    }
+    else {
+        const mismatches = feature.get('mismatches');
+        if (mismatches) {
+            for (const m of mismatches) {
+                let base;
+                let cliplen;
+                if (m.type === 'mismatch') {
+                    base = m.base;
+                }
+                else if (m.type === 'insertion') {
+                    base = m.insertedBases ?? '';
+                    cliplen = m.insertlen;
+                }
+                else if (m.type === 'softclip' || m.type === 'hardclip') {
+                    base = '';
+                    cliplen = m.cliplen;
+                }
+                else {
+                    base = '';
+                }
+                mismatchHandler(MISMATCH_REV_MAP[m.type], m.start, m.length, base, m.type === 'mismatch' ? m.qual : undefined, m.type === 'mismatch' ? m.altbase?.charCodeAt(0) : undefined, cliplen);
+            }
+        }
+    }
+}

package/esm/SNPCoverageAdapter/index.js

@@ -1,5 +1,5 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
-import configSchema from './configSchema';
+import configSchema from "./configSchema.js";
 export default function SNPCoverageAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => {
         return new AdapterType({
@@ -8,7 +8,7 @@ export default function SNPCoverageAdapterF(pluginManager) {
             adapterMetadata: {
                 hiddenFromGUI: true,
             },
-            getAdapterClass: () => import('./SNPCoverageAdapter').then(r => r.default),
+            getAdapterClass: () => import("./SNPCoverageAdapter.js").then(r => r.default),
             configSchema,
         });
     });

package/esm/SNPCoverageAdapter/processDepthPrefixSum.d.ts

@@ -0,0 +1,10 @@
+import type { Feature } from '@jbrowse/core/util';
+import type { AugmentedRegion } from '@jbrowse/core/util/types';
+export interface CoverageDepthSoA {
+    regionStart: number;
+    regionSize: number;
+    depth: Int32Array;
+    strandPlus: Int32Array;
+    strandMinus: Int32Array;
+}
+export declare function processDepthPrefixSum(features: Feature[], region: AugmentedRegion): CoverageDepthSoA;

package/esm/SNPCoverageAdapter/processDepthPrefixSum.js

@@ -0,0 +1,55 @@
+const MAX_REGION_SIZE = 1_000_000;
+const depthChanges = new Int32Array(MAX_REGION_SIZE + 1);
+const strandPlusChanges = new Int32Array(MAX_REGION_SIZE + 1);
+const strandMinusChanges = new Int32Array(MAX_REGION_SIZE + 1);
+export function processDepthPrefixSum(features, region) {
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    const regionSize = regionEnd - regionStart;
+    if (regionSize > MAX_REGION_SIZE) {
+        throw new Error(`Region size ${regionSize} exceeds maximum ${MAX_REGION_SIZE}`);
+    }
+    depthChanges.fill(0, 0, regionSize + 1);
+    strandPlusChanges.fill(0, 0, regionSize + 1);
+    strandMinusChanges.fill(0, 0, regionSize + 1);
+    for (const feature of features) {
+        const fstart = feature.get('start');
+        const fend = feature.get('end');
+        const fstrand = feature.get('strand');
+        const visStart = Math.max(fstart, regionStart) - regionStart;
+        const visEnd = Math.min(fend, regionEnd) - regionStart;
+        if (visStart < visEnd) {
+            depthChanges[visStart]++;
+            depthChanges[visEnd]--;
+            if (fstrand === 1) {
+                strandPlusChanges[visStart]++;
+                strandPlusChanges[visEnd]--;
+            }
+            else if (fstrand === -1) {
+                strandMinusChanges[visStart]++;
+                strandMinusChanges[visEnd]--;
+            }
+        }
+    }
+    const depth = new Int32Array(regionSize);
+    const strandPlus = new Int32Array(regionSize);
+    const strandMinus = new Int32Array(regionSize);
+    let d = 0;
+    let sp = 0;
+    let sm = 0;
+    for (let i = 0; i < regionSize; i++) {
+        d += depthChanges[i];
+        sp += strandPlusChanges[i];
+        sm += strandMinusChanges[i];
+        depth[i] = d;
+        strandPlus[i] = sp;
+        strandMinus[i] = sm;
+    }
+    return {
+        regionStart,
+        regionSize,
+        depth,
+        strandPlus,
+        strandMinus,
+    };
+}

package/esm/SNPCoverageAdapter/processModifications.d.ts

@@ -1,4 +1,4 @@
-import type { ColorBy, PreBaseCoverageBin } from '../shared/types';
+import type { ColorBy, PreBaseCoverageBin } from '../shared/types.ts';
 import type { Feature } from '@jbrowse/core/util';
 import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
 export declare function processModifications({ feature, colorBy, region, bins, regionSequence, }: {

package/esm/SNPCoverageAdapter/processModifications.js

@@ -1,57 +1,45 @@
 import { max, sum } from '@jbrowse/core/util';
-import { incWithProbabilities } from './util';
-import { parseCigar } from '../MismatchParser';
-import { getMaxProbModAtEachPosition } from '../shared/getMaximumModificationAtEachPosition';
+import { createEmptyBin, incWithProbabilities } from "./util.js";
+import { parseCigar2 } from "../MismatchParser/index.js";
+import { getMaxProbModAtEachPosition } from "../shared/getMaximumModificationAtEachPosition.js";
 export function processModifications({ feature, colorBy, region, bins, regionSequence, }) {
-    var _a, _b, _c, _d, _e;
     const fstart = feature.get('start');
     const fstrand = feature.get('strand');
     const fend = feature.get('end');
-    const twoColor = (_a = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _a === void 0 ? void 0 : _a.twoColor;
-    const isolatedModification = (_b = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _b === void 0 ? void 0 : _b.isolatedModification;
+    const twoColor = colorBy?.modifications?.twoColor;
+    const isolatedModification = colorBy?.modifications?.isolatedModification;
     const seq = feature.get('seq');
-    const modificationThreshold = (_d = (_c = colorBy === null || colorBy === void 0 ? void 0 : colorBy.modifications) === null || _c === void 0 ? void 0 : _c.threshold) !== null && _d !== void 0 ? _d : 10;
+    const modificationThreshold = colorBy?.modifications?.threshold ?? 10;
     const thresholdFraction = modificationThreshold / 100;
     if (!seq) {
         return;
     }
-    const cigarOps = parseCigar(feature.get('CIGAR'));
-    (_e = getMaxProbModAtEachPosition(feature, cigarOps)) === null || _e === void 0 ? void 0 : _e.forEach(({ allProbs, prob, type }, pos) => {
+    const cigarOps = feature.get('NUMERIC_CIGAR') ?? parseCigar2(feature.get('CIGAR'));
+    const regionStart = region.start;
+    const regionEnd = region.end;
+    getMaxProbModAtEachPosition(feature, cigarOps)?.forEach(({ allProbs, prob, type }, pos) => {
+        const refPos = pos + fstart;
+        if (refPos < regionStart || refPos >= fend) {
+            return;
+        }
+        const epos = refPos - regionStart;
+        if (epos < 0 || epos >= regionEnd - regionStart) {
+            return;
+        }
         if (isolatedModification && type !== isolatedModification) {
             return;
         }
         if (prob < thresholdFraction) {
             return;
         }
-        const epos = pos + fstart - region.start;
-        if (epos >= 0 && epos < bins.length && pos + fstart < fend) {
-            if (bins[epos] === undefined) {
-                bins[epos] = {
-                    depth: 0,
-                    readsCounted: 0,
-                    snps: {},
-                    ref: {
-                        probabilities: [],
-                        entryDepth: 0,
-                        '-1': 0,
-                        0: 0,
-                        1: 0,
-                    },
-                    mods: {},
-                    nonmods: {},
-                    delskips: {},
-                    noncov: {},
-                };
-            }
-            const bin = bins[epos];
-            bin.refbase = regionSequence[epos];
-            const s = 1 - sum(allProbs);
-            if (twoColor && s > max(allProbs)) {
-                incWithProbabilities(bin, fstrand, 'nonmods', `nonmod_${type}`, s);
-            }
-            else {
-                incWithProbabilities(bin, fstrand, 'mods', `mod_${type}`, prob);
-            }
+        const bin = (bins[epos] ??= createEmptyBin());
+        bin.refbase = regionSequence[epos];
+        const s = 1 - sum(allProbs);
+        if (twoColor && s > max(allProbs)) {
+            incWithProbabilities(bin, fstrand, 'nonmods', `nonmod_${type}`, s);
+        }
+        else {
+            incWithProbabilities(bin, fstrand, 'mods', `mod_${type}`, prob);
         }
     });
 }

package/esm/SNPCoverageAdapter/processReferenceCpGs.d.ts

@@ -1,9 +1,8 @@
-import type { PreBaseCoverageBin } from '../shared/types';
-import type { Feature } from '@jbrowse/core/util';
+import type { FeatureWithMismatchIterator, PreBaseCoverageBin } from '../shared/types.ts';
 import type { AugmentedRegion as Region } from '@jbrowse/core/util/types';
 export declare function processReferenceCpGs({ feature, region, bins, regionSequence, }: {
     bins: PreBaseCoverageBin[];
-    feature: Feature;
+    feature: FeatureWithMismatchIterator;
     region: Region;
     regionSequence: string;
 }): void;