jbrowse-plugin-msaview 2.4.5 → 2.5.0

package/dist/MsaViewPanel/model.js

@@ -5,11 +5,10 @@ import { addDisposer, types } from '@jbrowse/mobx-state-tree';
 import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
 import { autorun } from 'mobx';
 import { MSAModelF } from 'react-msaview';
-import { autoConnectStructures, highlightConnectedStructures, launchBlastIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, } from './afterCreateAutoruns';
-import { genomeToMSA } from './genomeToMSA';
+import { autoConnectStructures, highlightConnectedStructures, launchBlastIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
 import { msaCoordToGenomeCoord } from './msaCoordToGenomeCoord';
 import { buildAlignmentMaps, runPairwiseAlignment } from './pairwiseAlignment';
-import { getProteinViews, ungappedToGappedPosition, } from './structureConnection';
+import { getProteinViews } from './structureConnection';
 import { getCanonicalRefName } from './util';
 const ConnectStructureDialog = lazy(() => import('./components/ConnectStructureDialog'));
 /**
@@ -132,37 +131,6 @@ export default function stateModelFactory() {
         },
     }))
         .views(self => ({
-        /**
-         * #getter
-         */
-        get structureHoverCol() {
-            for (const conn of self.connectedProteinViews) {
-                const structure = conn.proteinView.structures[conn.structureIdx];
-                const structurePos = structure?.hoverPosition?.structureSeqPos;
-                if (structurePos !== undefined) {
-                    const msaUngapped = conn.structureToMsa[structurePos];
-                    if (msaUngapped !== undefined) {
-                        const seq = self.getSequenceByRowName(conn.msaRowName);
-                        if (seq) {
-                            const globalCol = ungappedToGappedPosition(seq, msaUngapped);
-                            if (globalCol !== undefined) {
-                                return self.globalColToVisibleCol(globalCol);
-                            }
-                        }
-                    }
-                }
-            }
-            return undefined;
-        },
-    }))
-        .views(self => ({
-        /**
-         * #getter
-         */
-        get mouseCol2() {
-            return (self.structureHoverCol ??
-                genomeToMSA({ model: self }));
-        },
         /**
          * #getter
          */
@@ -296,13 +264,12 @@ export default function stateModelFactory() {
                 throw new Error('Structure sequence not available');
             }
             const alignment = runPairwiseAlignment(ungappedMsaSequence, structureSequence);
-            const { seq1ToSeq2, seq2ToSeq1 } = buildAlignmentMaps(alignment);
+            const { seq1ToSeq2 } = buildAlignmentMaps(alignment);
             const connection = {
                 proteinViewId,
                 structureIdx,
                 msaRowName: rowName,
                 msaToStructure: Object.fromEntries(seq1ToSeq2),
-                structureToMsa: Object.fromEntries(seq2ToSeq1),
             };
             self.connectedStructures.push(connection);
         },
@@ -392,6 +359,7 @@ export default function stateModelFactory() {
                     fn(self);
                 }));
             }
+            addDisposer(self, autorun(syncGenomeHoverToMsaColumn(self)));
         },
     }));
 }

package/dist/MsaViewPanel/pairwiseAlignment.js

@@ -93,15 +93,8 @@ function buildConsensus(alignedSeq1, alignedSeq2) {
     for (let i = 0; i < alignedSeq1.length; i++) {
         const a = alignedSeq1[i];
         const b = alignedSeq2[i];
-        if (a === '-' || b === '-') {
-            consensus += ' ';
-        }
-        else if (a.toUpperCase() === b.toUpperCase()) {
-            consensus += '|';
-        }
-        else {
-            consensus += ' ';
-        }
+        const match = a !== '-' && b !== '-' && a.toUpperCase() === b.toUpperCase();
+        consensus += match ? '|' : ' ';
     }
     return consensus;
 }

package/dist/MsaViewPanel/structureConnection.d.ts

@@ -38,14 +38,8 @@ export interface StructureConnection {
     msaRowName: string;
     /** Map from MSA ungapped position to structure sequence position */
     msaToStructure: Record<number, number>;
-    /** Map from structure sequence position to MSA ungapped position */
-    structureToMsa: Record<number, number>;
 }
 /**
  * Helper to convert gapped MSA column to ungapped position for a specific row
  */
 export declare function gappedToUngappedPosition(sequence: string, gappedPosition: number): number | undefined;
-/**
- * Helper to convert ungapped position to gapped MSA column for a specific row
- */
-export declare function ungappedToGappedPosition(sequence: string, ungappedPosition: number): number | undefined;

package/dist/MsaViewPanel/structureConnection.js

@@ -27,19 +27,3 @@ export function gappedToUngappedPosition(sequence, gappedPosition) {
     }
     return ungapped;
 }
-/**
- * Helper to convert ungapped position to gapped MSA column for a specific row
- */
-export function ungappedToGappedPosition(sequence, ungappedPosition) {
-    let ungapped = 0;
-    for (let i = 0; i < sequence.length; i++) {
-        const element = sequence[i];
-        if (element !== '-') {
-            if (ungapped === ungappedPosition) {
-                return i;
-            }
-            ungapped++;
-        }
-    }
-    return undefined;
-}

package/dist/MsaViewPanel/structureConnection.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { gappedToUngappedPosition, ungappedToGappedPosition, } from './structureConnection';
+import { gappedToUngappedPosition } from './structureConnection';
 describe('gappedToUngappedPosition', () => {
     test('returns correct ungapped position for non-gap character', () => {
         const seq = 'M-KA-A';
@@ -51,53 +51,3 @@ describe('gappedToUngappedPosition', () => {
         expect(gappedToUngappedPosition(seq, 2)).toBeUndefined();
     });
 });
-describe('ungappedToGappedPosition', () => {
-    test('returns correct gapped position', () => {
-        const seq = 'M-KA-A';
-        //           0 12 34  (gapped)
-        //           0  1  23 (ungapped)
-        expect(ungappedToGappedPosition(seq, 0)).toBe(0); // M
-        expect(ungappedToGappedPosition(seq, 1)).toBe(2); // K
-        expect(ungappedToGappedPosition(seq, 2)).toBe(3); // A
-        expect(ungappedToGappedPosition(seq, 3)).toBe(5); // A
-    });
-    test('returns undefined for out-of-bounds ungapped position', () => {
-        const seq = 'M-KA';
-        expect(ungappedToGappedPosition(seq, 4)).toBeUndefined();
-        expect(ungappedToGappedPosition(seq, 100)).toBeUndefined();
-    });
-    test('handles sequence with no gaps', () => {
-        const seq = 'MKAA';
-        expect(ungappedToGappedPosition(seq, 0)).toBe(0);
-        expect(ungappedToGappedPosition(seq, 1)).toBe(1);
-        expect(ungappedToGappedPosition(seq, 2)).toBe(2);
-        expect(ungappedToGappedPosition(seq, 3)).toBe(3);
-    });
-    test('handles sequence with leading gaps', () => {
-        const seq = '--MKA';
-        expect(ungappedToGappedPosition(seq, 0)).toBe(2); // M
-        expect(ungappedToGappedPosition(seq, 1)).toBe(3); // K
-        expect(ungappedToGappedPosition(seq, 2)).toBe(4); // A
-    });
-    test('handles empty sequence', () => {
-        expect(ungappedToGappedPosition('', 0)).toBeUndefined();
-    });
-    test('handles all-gap sequence', () => {
-        const seq = '---';
-        expect(ungappedToGappedPosition(seq, 0)).toBeUndefined();
-    });
-});
-describe('gappedToUngappedPosition and ungappedToGappedPosition are inverses', () => {
-    test('round-trip conversion works', () => {
-        const seq = 'M-KA--YL-S';
-        // For each non-gap position, converting to ungapped and back should return original
-        for (let i = 0; i < seq.length; i++) {
-            if (seq[i] !== '-') {
-                const ungapped = gappedToUngappedPosition(seq, i);
-                expect(ungapped).toBeDefined();
-                const backToGapped = ungappedToGappedPosition(seq, ungapped);
-                expect(backToGapped).toBe(i);
-            }
-        }
-    });
-});

package/dist/MsaViewPanel/syncGenomeHoverToMsaColumn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/MsaViewPanel/syncGenomeHoverToMsaColumn.test.js

@@ -0,0 +1,92 @@
+import { getSession } from '@jbrowse/core/util';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { syncGenomeHoverToMsaColumn } from './afterCreateAutoruns';
+// Mock only getSession; keep the rest of the util module real so the
+// afterCreateAutoruns import graph still loads.
+vi.mock('@jbrowse/core/util', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getSession: vi.fn(),
+}));
+const mockGetSession = vi.mocked(getSession);
+const mafRegion = {
+    refName: 'chr1',
+    start: 1000,
+    end: 1010,
+    assemblyName: 'hg38',
+};
+// A model wired through the real genomeToMSA path: a connected genome view
+// over a maf region, with seqPosToVisibleCol as identity so the asserted
+// column equals the ungapped offset into the region.
+function makeModel() {
+    const calls = [];
+    const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion,
+        connectedView: { initialized: true, assemblyNames: ['hg38'] },
+        seqPosToVisibleCol: (_name, pos) => pos,
+        setMousePos: (col) => {
+            calls.push(col);
+        },
+    };
+    return { model, calls };
+}
+function hoverGenome(coord) {
+    mockGetSession.mockReturnValue({
+        hovered: { hoverFeature: {}, hoverPosition: { coord, refName: 'chr1' } },
+    });
+}
+function clearGenomeHover() {
+    mockGetSession.mockReturnValue({
+        hovered: null,
+    });
+}
+describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    test('genome hover at coord 1005 highlights MSA column 5', () => {
+        const { model, calls } = makeModel();
+        const run = syncGenomeHoverToMsaColumn(model);
+        hoverGenome(1005); // 1005 - mafRegion.start(1000) = ungapped 5
+        run();
+        expect(calls).toEqual([5]);
+    });
+    test('moving the genome hover moves the highlighted column', () => {
+        const { model, calls } = makeModel();
+        const run = syncGenomeHoverToMsaColumn(model);
+        hoverGenome(1002);
+        run();
+        hoverGenome(1007);
+        run();
+        expect(calls).toEqual([2, 7]);
+    });
+    test('leaving the genome clears the column it set', () => {
+        const { model, calls } = makeModel();
+        const run = syncGenomeHoverToMsaColumn(model);
+        hoverGenome(1004);
+        run();
+        clearGenomeHover();
+        run();
+        expect(calls).toEqual([4, undefined]);
+    });
+    test('a hover outside the maf region clears a previously-set column once', () => {
+        const { model, calls } = makeModel();
+        const run = syncGenomeHoverToMsaColumn(model);
+        hoverGenome(1004);
+        run();
+        hoverGenome(5000); // outside [1000,1010) -> genomeToMSA returns undefined
+        run();
+        run();
+        expect(calls).toEqual([4, undefined]);
+    });
+    test('never touches mouseCol when the genome never provides a column, so a direct MSA hover survives unrelated session hovers', () => {
+        const { model, calls } = makeModel();
+        const run = syncGenomeHoverToMsaColumn(model);
+        clearGenomeHover();
+        run();
+        hoverGenome(9999); // unrelated/out-of-range hover elsewhere
+        run();
+        expect(calls).toEqual([]);
+    });
+});