jbrowse-plugin-msaview 2.6.1 → 2.6.3

package/dist/LaunchMsaViewExtensionPoint/index.js

@@ -1,33 +1,31 @@
 export default function LaunchMsaViewExtensionPointF(pluginManager) {
-    pluginManager.addToExtensionPoint('LaunchView-MsaView', 
-    // @ts-expect-error
-    ({ session, data, msaFileLocation, msaIndexedLocation, msaName, treeFileLocation, connectedViewId, connectedFeature, displayName, colorSchemeName, colWidth, rowHeight, treeAreaWidth, treeWidth, drawNodeBubbles, labelsAlignRight, showBranchLen, querySeqName, highlightColumns, }) => {
+    pluginManager.addToExtensionPoint('LaunchView-MsaView', (args) => {
+        const { session, data, msaFileLocation, msaIndexedLocation, msaName, treeFileLocation, querySeqName, ...rest } = args;
         if (!data && !msaFileLocation && !msaIndexedLocation) {
             throw new Error('No MSA data or file location provided when launching MSA view');
         }
+        // inline data and the tree URL are native react-msaview snapshot props, set
+        // directly. Only sources needing launch-time resolution go through `init`:
+        // msaUrl (AlphaFold sniff) and the name-indexed bgzip block (no native loader).
         session.addView('MsaView', {
             type: 'MsaView',
-            displayName,
-            connectedViewId,
-            connectedFeature,
-            colorSchemeName,
-            colWidth,
-            rowHeight,
-            treeAreaWidth,
-            treeWidth,
-            drawNodeBubbles,
-            labelsAlignRight,
-            showBranchLen,
-            highlightColumns,
+            ...rest,
+            data,
+            ...(treeFileLocation
+                ? {
+                    treeFilehandle: {
+                        ...treeFileLocation,
+                        locationType: 'UriLocation',
+                    },
+                }
+                : {}),
             init: {
-                msaData: data?.msa,
-                treeData: data?.tree,
                 msaUrl: msaFileLocation?.uri,
                 msaIndexedLocation,
                 msaName,
-                treeUrl: treeFileLocation?.uri,
                 querySeqName,
             },
         });
+        return args;
     });
 }

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -4,7 +4,7 @@ import { fetchIndexedMsa } from './fetchIndexedMsa';
 import { genomeToMSA } from './genomeToMSA';
 import { loadProteinDomains } from './loadProteinDomains';
 import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
-import { gappedToUngappedPosition, getProteinViews, } from './structureConnection';
+import { gappedToUngappedPosition, getProteinViews, structureMatchesMsa, } from './structureConnection';
 import { getUniprotIdFromAlphaFoldUrl } from './util';
 export function loadStoredData(self) {
     const { dataStoreId, rows } = self;
@@ -116,13 +116,18 @@ export function autoLoadProteinDomains(self) {
         })();
     }
 }
+// Resolve the declarative `init` launch contract once, then clear it. msaUrl is
+// handed to react-msaview's native filehandle loader (openLocation + progress +
+// abort + CORS-proxy) and sniffed for an AlphaFold uniprotId; the bgzip
+// name-indexed block is the one source with no native loader, so it's fetched
+// here. Inline data and tree URLs arrive as native snapshot props, not via init.
 export function processInit(self) {
     const { init } = self;
     if (init) {
+        const { msaUrl, msaIndexedLocation, msaName, querySeqName } = init;
         void (async () => {
             try {
                 self.setError(undefined);
-                const { msaData, msaUrl, msaIndexedLocation, msaName, treeData, treeUrl, querySeqName, } = init;
                 if (msaUrl) {
                     const id = getUniprotIdFromAlphaFoldUrl(msaUrl);
                     if (id) {
@@ -133,16 +138,8 @@ export function processInit(self) {
                 if (querySeqName) {
                     self.setQuerySeqName(querySeqName);
                 }
-                if (msaData) {
-                    self.setMSA(msaData);
-                }
-                else if (msaUrl) {
-                    const response = await fetch(msaUrl);
-                    if (!response.ok) {
-                        throw new Error(`Failed to fetch MSA: ${response.status}`);
-                    }
-                    const data = await response.text();
-                    self.setMSA(data);
+                if (msaUrl) {
+                    self.setMSAFilehandle({ uri: msaUrl, locationType: 'UriLocation' });
                 }
                 else if (msaIndexedLocation && msaName) {
                     const fasta = await fetchIndexedMsa({
@@ -156,17 +153,6 @@ export function processInit(self) {
                         throw new Error(`No alignment named ${msaName} in ${msaIndexedLocation.uri}`);
                     }
                 }
-                if (treeData) {
-                    self.setTree(treeData);
-                }
-                else if (treeUrl) {
-                    const response = await fetch(treeUrl);
-                    if (!response.ok) {
-                        throw new Error(`Failed to fetch tree: ${response.status}`);
-                    }
-                    const data = await response.text();
-                    self.setTree(data);
-                }
                 self.setInit(undefined);
             }
             catch (e) {
@@ -231,7 +217,7 @@ export function highlightConnectedStructures(self) {
 }
 export function autoConnectStructures(self) {
     const { connectedViewId, uniprotId, rows, connectedStructures } = self;
-    if (!uniprotId || rows.length === 0) {
+    if (rows.length === 0) {
         return;
     }
     for (const view of getProteinViews(getSession(self).views)) {
@@ -240,10 +226,7 @@ export function autoConnectStructures(self) {
             if (!structure) {
                 continue;
             }
-            if (structure.connectedViewId !== connectedViewId) {
-                continue;
-            }
-            if (structure.uniprotId !== uniprotId) {
+            if (!structureMatchesMsa({ structure, connectedViewId, uniprotId })) {
                 continue;
             }
             const alreadyConnected = connectedStructures.some(c => c.proteinViewId === view.id && c.structureIdx === structureIdx);

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

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

package/dist/MsaViewPanel/autoConnectStructures.test.js

@@ -0,0 +1,60 @@
+import { getSession } from '@jbrowse/core/util';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { autoConnectStructures } from './afterCreateAutoruns';
+// Integration coverage for the autorun itself — the structure-matching matrix
+// lives in structureConnection.test.ts (structureMatchesMsa). Here we check the
+// autorun wires a match through to connectToStructure and respects its guards.
+// 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);
+function makeModel(opts) {
+    const connected = [];
+    const model = {
+        connectedViewId: opts.connectedViewId,
+        uniprotId: opts.uniprotId,
+        rows: [['hg38', 'MKATEST']],
+        connectedStructures: connected,
+        connectToStructure: (proteinViewId, structureIdx) => {
+            connected.push({ proteinViewId, structureIdx });
+        },
+    };
+    return { model, connected };
+}
+function withStructure(structure) {
+    const view = {
+        type: 'ProteinView',
+        id: 'pv1',
+        structures: [{ ...structure, structureSequences: ['MKATEST'] }],
+    };
+    mockGetSession.mockReturnValue({
+        views: [view],
+    });
+}
+describe('autoConnectStructures', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    test('connects a matching structure (genome-view link, no UniProt id)', () => {
+        const { model, connected } = makeModel({ connectedViewId: 'lgv-TP53' });
+        withStructure({ connectedViewId: 'lgv-TP53' });
+        autoConnectStructures(model);
+        expect(connected).toEqual([{ proteinViewId: 'pv1', structureIdx: 0 }]);
+    });
+    test('does not connect a non-matching structure', () => {
+        const { model, connected } = makeModel({ connectedViewId: 'lgv-TP53' });
+        withStructure({ connectedViewId: 'lgv-OTHER' });
+        autoConnectStructures(model);
+        expect(connected).toEqual([]);
+    });
+    test('does not connect before the alignment has loaded (no rows)', () => {
+        const { model, connected } = makeModel({ connectedViewId: 'lgv-TP53' });
+        model.rows = [];
+        withStructure({ connectedViewId: 'lgv-TP53' });
+        autoConnectStructures(model);
+        expect(connected).toEqual([]);
+    });
+});

package/dist/MsaViewPanel/structureConnection.d.ts

@@ -26,6 +26,26 @@ export declare function isProteinView(view: unknown): view is ProteinView;
 export declare function getProteinViews(views: {
     type: string;
 }[]): ProteinView[];
+/**
+ * Whether a 3D structure belongs to a given alignment — the single source of
+ * truth for pairing an MsaView with a ProteinView's structure. A structure
+ * matches when it either:
+ *  - shares the alignment's genome view (both pinned to the same
+ *    LinearGenomeView via `connectedViewId` — the genome-centric gene-explorer
+ *    flow, the same key genome↔MSA and genome↔structure already bridge through),
+ *    or
+ *  - shares the alignment's UniProt accession (the BLAST/AlphaFold flow, which
+ *    has no genome view to bridge through).
+ *
+ * The residue map itself is built by sequence (connectToStructure pairwise-
+ * aligns the query row against the structure), so neither key is mechanically
+ * required — they only scope WHICH structure pairs with the alignment.
+ */
+export declare function structureMatchesMsa({ structure, connectedViewId, uniprotId, }: {
+    structure: Pick<ProteinViewStructure, 'connectedViewId' | 'uniprotId'>;
+    connectedViewId?: string;
+    uniprotId?: string;
+}): boolean;
 /**
  * Represents a connection between the MSA view and a protein structure
  */

package/dist/MsaViewPanel/structureConnection.js

@@ -8,6 +8,26 @@ export function isProteinView(view) {
 export function getProteinViews(views) {
     return views.filter(isProteinView);
 }
+/**
+ * Whether a 3D structure belongs to a given alignment — the single source of
+ * truth for pairing an MsaView with a ProteinView's structure. A structure
+ * matches when it either:
+ *  - shares the alignment's genome view (both pinned to the same
+ *    LinearGenomeView via `connectedViewId` — the genome-centric gene-explorer
+ *    flow, the same key genome↔MSA and genome↔structure already bridge through),
+ *    or
+ *  - shares the alignment's UniProt accession (the BLAST/AlphaFold flow, which
+ *    has no genome view to bridge through).
+ *
+ * The residue map itself is built by sequence (connectToStructure pairwise-
+ * aligns the query row against the structure), so neither key is mechanically
+ * required — they only scope WHICH structure pairs with the alignment.
+ */
+export function structureMatchesMsa({ structure, connectedViewId, uniprotId, }) {
+    const sharesGenomeView = !!connectedViewId && structure.connectedViewId === connectedViewId;
+    const sharesUniprot = !!uniprotId && structure.uniprotId === uniprotId;
+    return sharesGenomeView || sharesUniprot;
+}
 /**
  * Helper to convert gapped MSA column to ungapped position for a specific row
  */

package/dist/MsaViewPanel/structureConnection.test.js

@@ -1,5 +1,39 @@
 import { describe, expect, test } from 'vitest';
-import { gappedToUngappedPosition } from './structureConnection';
+import { gappedToUngappedPosition, structureMatchesMsa, } from './structureConnection';
+describe('structureMatchesMsa', () => {
+    test('matches on a shared genome view alone (no UniProt id)', () => {
+        expect(structureMatchesMsa({
+            structure: { connectedViewId: 'lgv-TP53' },
+            connectedViewId: 'lgv-TP53',
+        })).toBe(true);
+    });
+    test('matches on a shared UniProt id alone (no genome view)', () => {
+        expect(structureMatchesMsa({
+            structure: { uniprotId: 'P04637' },
+            uniprotId: 'P04637',
+        })).toBe(true);
+    });
+    test('shared genome view wins even when UniProt ids differ', () => {
+        expect(structureMatchesMsa({
+            structure: { connectedViewId: 'lgv-TP53', uniprotId: 'OTHER' },
+            connectedViewId: 'lgv-TP53',
+            uniprotId: 'P04637',
+        })).toBe(true);
+    });
+    test('no match when neither key matches', () => {
+        expect(structureMatchesMsa({
+            structure: { connectedViewId: 'lgv-OTHER', uniprotId: 'OTHER' },
+            connectedViewId: 'lgv-TP53',
+            uniprotId: 'P04637',
+        })).toBe(false);
+    });
+    test('two undefined connectedViewIds do not count as a shared genome view', () => {
+        // both sides lacking a genome view must NOT auto-pair on `undefined ===
+        // undefined`; only an explicit shared id (or UniProt id) connects
+        expect(structureMatchesMsa({ structure: {} })).toBe(false);
+        expect(structureMatchesMsa({ structure: { uniprotId: 'P04637' } })).toBe(false);
+    });
+});
 describe('gappedToUngappedPosition', () => {
     test('returns correct ungapped position for non-gap character', () => {
         const seq = 'M-KA-A';

package/dist/MsaViewPanel/types.d.ts

@@ -1,13 +1,10 @@
 export interface MsaViewInitState {
-    msaData?: string;
     msaUrl?: string;
+    querySeqName?: string;
     msaIndexedLocation?: {
         uri: string;
     };
     msaName?: string;
-    treeData?: string;
-    treeUrl?: string;
-    querySeqName?: string;
 }
 export interface MafRegion {
     refName: string;