jbrowse-plugin-msaview 2.6.1 → 2.6.3

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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

package/src/LaunchMsaViewExtensionPoint/index.ts

@@ -1,83 +1,75 @@
 import type PluginManager from '@jbrowse/core/PluginManager'
 import type { AbstractSessionModel } from '@jbrowse/core/util'
 
+interface LaunchMsaViewArgs {
+  session: AbstractSessionModel
+  data?: { msa: string; tree?: string }
+  msaFileLocation?: { uri: string }
+  msaIndexedLocation?: { uri: string }
+  msaName?: string
+  treeFileLocation?: { uri: string }
+  connectedViewId?: string
+  connectedFeature?: Record<string, unknown>
+  displayName?: string
+  colorSchemeName?: string
+  colWidth?: number
+  rowHeight?: number
+  treeAreaWidth?: number
+  treeWidth?: number
+  drawNodeBubbles?: boolean
+  labelsAlignRight?: boolean
+  showBranchLen?: boolean
+  querySeqName?: string
+  highlightColumns?: number[]
+}
+
 export default function LaunchMsaViewExtensionPointF(
   pluginManager: 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,
-    }: {
-      session: AbstractSessionModel
-      data?: { msa: string; tree?: string }
-      msaFileLocation?: { uri: string }
-      msaIndexedLocation?: { uri: string }
-      msaName?: string
-      treeFileLocation?: { uri: string }
-      connectedViewId?: string
-      connectedFeature?: Record<string, unknown>
-      displayName?: string
-      colorSchemeName?: string
-      colWidth?: number
-      rowHeight?: number
-      treeAreaWidth?: number
-      treeWidth?: number
-      drawNodeBubbles?: boolean
-      labelsAlignRight?: boolean
-      showBranchLen?: boolean
-      querySeqName?: string
-      highlightColumns?: number[]
-    }) => {
+    (args: LaunchMsaViewArgs) => {
+      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/src/MsaViewPanel/afterCreateAutoruns.ts

@@ -13,6 +13,7 @@ import {
 import {
   gappedToUngappedPosition,
   getProteinViews,
+  structureMatchesMsa,
 } from './structureConnection'
 import { getUniprotIdFromAlphaFoldUrl } from './util'
 
@@ -128,21 +129,18 @@ export function autoLoadProteinDomains(self: JBrowsePluginMsaViewModel) {
   }
 }
 
+// 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 { 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)
@@ -151,20 +149,12 @@ export function processInit(self: JBrowsePluginMsaViewModel) {
             self.setQuerySeqName('query')
           }
         }
-
         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({
             location: msaIndexedLocation,
@@ -179,17 +169,6 @@ export function processInit(self: JBrowsePluginMsaViewModel) {
           }
         }
 
-        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) {
         self.setError(e)
@@ -260,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
   }
 
@@ -275,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,16 +1,24 @@
+// 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.1'
+export const version = '2.6.3'