jbrowse-plugin-msaview 2.6.2 → 2.6.3

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.6.2";
+export declare const version = "2.6.3";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.6.2';
+export const version = '2.6.3';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.6.2",
+  "version": "2.6.3",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {

package/src/LaunchMsaViewExtensionPoint/index.ts

@@ -46,18 +46,25 @@ export default function LaunchMsaViewExtensionPointF(
         )
       }
 
-      // all data sources flow through `init` so processInit is the single place
-      // that resolves them (AlphaFold detection, native filehandle loading, etc.)
+      // 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',
         ...rest,
+        data,
+        ...(treeFileLocation
+          ? {
+              treeFilehandle: {
+                ...treeFileLocation,
+                locationType: 'UriLocation',
+              },
+            }
+          : {}),
         init: {
-          msaData: data?.msa,
-          treeData: data?.tree,
           msaUrl: msaFileLocation?.uri,
           msaIndexedLocation,
           msaName,
-          treeUrl: treeFileLocation?.uri,
           querySeqName,
         },
       })

package/src/MsaViewPanel/afterCreateAutoruns.ts

@@ -13,6 +13,7 @@ import {
 import {
   gappedToUngappedPosition,
   getProteinViews,
+  structureMatchesMsa,
 } from './structureConnection'
 import { getUniprotIdFromAlphaFoldUrl } from './util'
 
@@ -128,22 +129,15 @@ export function autoLoadProteinDomains(self: JBrowsePluginMsaViewModel) {
   }
 }
 
-// Resolve the declarative `init` launch contract once. Inline strings go straight
-// to the data model; URLs are handed to react-msaview's native filehandle loaders
-// (openLocation + progress + abort + CORS-proxy) rather than a hand-rolled fetch;
-// the bgzip name-indexed block is the one source with no native loader.
+// 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: JBrowsePluginMsaViewModel) {
   const { init } = self
   if (init) {
-    const {
-      msaData,
-      msaUrl,
-      msaIndexedLocation,
-      msaName,
-      treeData,
-      treeUrl,
-      querySeqName,
-    } = init
+    const { msaUrl, msaIndexedLocation, msaName, querySeqName } = init
     void (async () => {
       try {
         self.setError(undefined)
@@ -159,9 +153,7 @@ export function processInit(self: JBrowsePluginMsaViewModel) {
           self.setQuerySeqName(querySeqName)
         }
 
-        if (msaData) {
-          self.setMSA(msaData)
-        } else if (msaUrl) {
+        if (msaUrl) {
           self.setMSAFilehandle({ uri: msaUrl, locationType: 'UriLocation' })
         } else if (msaIndexedLocation && msaName) {
           const fasta = await fetchIndexedMsa({
@@ -177,12 +169,6 @@ export function processInit(self: JBrowsePluginMsaViewModel) {
           }
         }
 
-        if (treeData) {
-          self.setTree(treeData)
-        } else if (treeUrl) {
-          self.setTreeFilehandle({ uri: treeUrl, locationType: 'UriLocation' })
-        }
-
         self.setInit(undefined)
       } catch (e) {
         self.setError(e)
@@ -253,7 +239,7 @@ export function highlightConnectedStructures(self: JBrowsePluginMsaViewModel) {
 export function autoConnectStructures(self: JBrowsePluginMsaViewModel) {
   const { connectedViewId, uniprotId, rows, connectedStructures } = self
 
-  if (!uniprotId || rows.length === 0) {
+  if (rows.length === 0) {
     return
   }
 
@@ -268,11 +254,7 @@ export function autoConnectStructures(self: JBrowsePluginMsaViewModel) {
         continue
       }
 
-      if (structure.connectedViewId !== connectedViewId) {
-        continue
-      }
-
-      if (structure.uniprotId !== uniprotId) {
+      if (!structureMatchesMsa({ structure, connectedViewId, uniprotId })) {
         continue
       }
 

package/src/MsaViewPanel/autoConnectStructures.test.ts

@@ -0,0 +1,76 @@
+import { getSession } from '@jbrowse/core/util'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { autoConnectStructures } from './afterCreateAutoruns'
+
+import type { JBrowsePluginMsaViewModel } from './model'
+import type { ProteinView } from './structureConnection'
+
+// 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<Record<string, unknown>>()),
+  getSession: vi.fn(),
+}))
+
+const mockGetSession = vi.mocked(getSession)
+
+function makeModel(opts: { connectedViewId?: string; uniprotId?: string }) {
+  const connected: { proteinViewId: string; structureIdx: number }[] = []
+  const model = {
+    connectedViewId: opts.connectedViewId,
+    uniprotId: opts.uniprotId,
+    rows: [['hg38', 'MKATEST']],
+    connectedStructures: connected,
+    connectToStructure: (proteinViewId: string, structureIdx: number) => {
+      connected.push({ proteinViewId, structureIdx })
+    },
+  } as unknown as JBrowsePluginMsaViewModel
+  return { model, connected }
+}
+
+function withStructure(structure: {
+  connectedViewId?: string
+  uniprotId?: string
+}) {
+  const view: ProteinView = {
+    type: 'ProteinView',
+    id: 'pv1',
+    structures: [{ ...structure, structureSequences: ['MKATEST'] }],
+  }
+  mockGetSession.mockReturnValue({
+    views: [view],
+  } as unknown as ReturnType<typeof getSession>)
+}
+
+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 as unknown as { rows: unknown[] }).rows = []
+    withStructure({ connectedViewId: 'lgv-TP53' })
+    autoConnectStructures(model)
+    expect(connected).toEqual([])
+  })
+})

package/src/MsaViewPanel/structureConnection.test.ts

@@ -1,6 +1,58 @@
 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', () => {

package/src/MsaViewPanel/structureConnection.ts

@@ -28,6 +28,36 @@ export function getProteinViews(views: { type: string }[]): ProteinView[] {
   return (views as unknown[]).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,
+}: {
+  structure: Pick<ProteinViewStructure, 'connectedViewId' | 'uniprotId'>
+  connectedViewId?: string
+  uniprotId?: string
+}) {
+  const sharesGenomeView =
+    !!connectedViewId && structure.connectedViewId === connectedViewId
+  const sharesUniprot = !!uniprotId && structure.uniprotId === uniprotId
+  return sharesGenomeView || sharesUniprot
+}
+
 /**
  * Represents a connection between the MSA view and a protein structure
  */

package/src/MsaViewPanel/types.ts

@@ -1,19 +1,24 @@
-// Declarative launch contract, resolved once by processInit. This is also a
-// cross-repo contract: jbrowse-plugin-protein3d builds an MsaView snapshot
-// directly with `init: { msaUrl }`, so these keys must stay stable.
+// Declarative launch contract, resolved once by processInit, then cleared. Only
+// sources that need launch-time resolution belong here. Inline data and tree URLs
+// do NOT: they are native react-msaview snapshot props (`data`, `treeFilehandle`)
+// applied directly from the addView snapshot, no resolution required.
+//
+// Cross-repo contract: jbrowse-plugin-protein3d builds an MsaView snapshot directly
+// with `init: { msaUrl }`, so these keys must stay stable.
 export interface MsaViewInitState {
-  msaData?: string
+  // resolved here (not as a native msaFilehandle) so the AlphaFold-URL → uniprotId
+  // sniff runs once at launch; querySeqName is coupled to it (AlphaFold files name
+  // the query row 'query'), which is why it rides along in init rather than being a
+  // plain top-level prop.
   msaUrl?: string
+  querySeqName?: string
   // a single bgzip `.fa.gz` of per-transcript FASTA blocks; its `.gzi` and name
   // index `.idx` (name<TAB>offset<TAB>length) are found by suffix. `msaName`
   // selects one transcript's block by name (a random read), so one genome-scale
-  // alignment serves any gene without per-gene files or coordinates. See
-  // react-msaview's gene-explorer.
+  // alignment serves any gene without per-gene files or coordinates. This is the
+  // one alignment source with no native loader. See react-msaview's gene-explorer.
   msaIndexedLocation?: { uri: string }
   msaName?: string
-  treeData?: string
-  treeUrl?: string
-  querySeqName?: string
 }
 
 export interface MafRegion {

package/src/version.ts

@@ -1 +1 @@
-export const version = '2.6.2'
+export const version = '2.6.3'