jbrowse-plugin-msaview 2.2.2 → 2.2.4

package/src/MsaViewPanel/doLaunchBlast.ts

@@ -1,7 +1,13 @@
 import { JBrowsePluginMsaViewModel } from './model'
 import { makeId, strip } from '../LaunchMsaView/components/util'
+import { cleanProteinSequence } from '../LaunchMsaView/util'
+import { saveBlastResult } from '../utils/blastCache'
 import { launchMSA } from '../utils/msa'
 import { queryBlast } from '../utils/ncbiBlast'
+import { fetchTaxonomyInfo } from '../utils/taxonomyNames'
+
+import type { TaxonomyInfo } from '../utils/taxonomyNames'
+import type { BlastHitDescription } from '../utils/types'
 
 export async function doLaunchBlast({
   self,
@@ -14,42 +20,96 @@ export async function doLaunchBlast({
     blastProgram,
     msaAlgorithm,
     proteinSequence,
+    selectedTranscript,
   } = self.blastParams!
-  const { hits } = await queryBlast({
-    query: proteinSequence.replaceAll('*', '').replaceAll('&', ''),
+  const cleanedSeq = cleanProteinSequence(proteinSequence)
+
+  const { hits, rid } = await queryBlast({
+    query: cleanedSeq,
     blastDatabase,
     blastProgram,
     baseUrl,
     onProgress: arg => {
       self.setProgress(arg)
     },
-    onRid: rid => {
-      self.setRid(rid)
+    onRid: r => {
+      self.setRid(r)
     },
   })
 
-  return launchMSA({
+  self.setProgress('Fetching species taxonomy info...')
+  const taxids = hits
+    .map(h => h.description[0]?.taxid)
+    .filter((t): t is number => t !== undefined)
+  const taxonomyInfo = await fetchTaxonomyInfo(taxids)
+
+  const treeMetadata: Record<string, Record<string, string>> = {}
+
+  const sequences = hits.map(h => {
+    const desc = h.description[0] ?? {
+      accession: 'unknown',
+      id: 'unknown',
+      sciname: 'unknown',
+    }
+    const rowName = makeId(desc, taxonomyInfo)
+    const seq = strip(h.hsps[0]?.hseq ?? '')
+
+    treeMetadata[rowName] = buildRowMetadata(desc, taxonomyInfo)
+
+    return `>${rowName}\n${seq}`
+  })
+
+  const result = await launchMSA({
     algorithm: msaAlgorithm,
-    sequence: [
-      `>QUERY\n${proteinSequence.replaceAll('*', '').replaceAll('&', '')}`,
-      ...hits
-        .map(
-          h =>
-            [
-              makeId(
-                h.description[0] ?? {
-                  accession: 'unknown',
-                  id: 'unknown',
-                  sciname: 'unknown',
-                },
-              ),
-              strip(h.hsps[0]?.hseq ?? ''),
-            ] as const,
-        )
-        .map(([id, seq]) => `>${id}\n${seq}`),
-    ].join('\n'),
+    sequence: [`>QUERY\n${cleanedSeq}`, ...sequences].join('\n'),
     onProgress: arg => {
       self.setProgress(arg)
     },
   })
+
+  const treeMetadataJson = JSON.stringify(treeMetadata)
+
+  await saveBlastResult({
+    proteinSequence: cleanedSeq,
+    blastDatabase,
+    blastProgram,
+    msaAlgorithm,
+    msa: result.msa,
+    tree: result.tree,
+    treeMetadata: treeMetadataJson,
+    rid,
+    geneId: selectedTranscript?.get('parentId'),
+    transcriptId: selectedTranscript?.get('id'),
+  })
+
+  return {
+    ...result,
+    treeMetadata: treeMetadataJson,
+  }
+}
+
+function buildRowMetadata(
+  desc: BlastHitDescription,
+  taxonomyInfo: Map<number, TaxonomyInfo>,
+) {
+  const metadata: Record<string, string> = {}
+  const taxInfo = desc.taxid ? taxonomyInfo.get(desc.taxid) : undefined
+
+  if (taxInfo?.sciname) {
+    metadata['Scientific name'] = taxInfo.sciname
+  }
+  if (taxInfo?.commonName) {
+    metadata['Common name'] = taxInfo.commonName
+  }
+  if (desc.accession) {
+    metadata.Accession = desc.accession
+  }
+  if (desc.id) {
+    metadata.ID = desc.id
+  }
+  if (desc.title) {
+    metadata.Description = desc.title
+  }
+
+  return metadata
 }

package/src/MsaViewPanel/genomeToMSA.test.ts

@@ -0,0 +1,281 @@
+import { getSession } from '@jbrowse/core/util'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { genomeToMSA } from './genomeToMSA'
+
+// Mock getSession
+vi.mock('@jbrowse/core/util', () => ({
+  getSession: vi.fn(),
+}))
+
+const mockGetSession = vi.mocked(getSession)
+
+describe('genomeToMSA', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('returns undefined when connectedView is not initialized', () => {
+    mockGetSession.mockReturnValue({
+      hovered: {
+        hoverFeature: {},
+        hoverPosition: { coord: 1005, refName: 'chr1' },
+      },
+    } as any)
+
+    const model = {
+      querySeqName: 'hg38.chr1',
+      transcriptToMsaMap: undefined,
+      mafRegion: {
+        refName: 'chr1',
+        start: 1000,
+        end: 1010,
+        assemblyName: 'hg38',
+      },
+      connectedView: { initialized: false },
+      seqPosToVisibleCol: vi.fn(),
+    } as any
+
+    const result = genomeToMSA({ model })
+    expect(result).toBeUndefined()
+  })
+
+  test('returns undefined when hovered is not valid', () => {
+    mockGetSession.mockReturnValue({
+      hovered: null,
+    } as any)
+
+    const model = {
+      querySeqName: 'hg38.chr1',
+      transcriptToMsaMap: undefined,
+      mafRegion: {
+        refName: 'chr1',
+        start: 1000,
+        end: 1010,
+        assemblyName: 'hg38',
+      },
+      connectedView: { initialized: true },
+      seqPosToVisibleCol: vi.fn(),
+    } as any
+
+    const result = genomeToMSA({ model })
+    expect(result).toBeUndefined()
+  })
+
+  describe('mafRegion mapping', () => {
+    test('returns visible column for valid hover within mafRegion', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1005, refName: 'chr1' },
+        },
+      } as any)
+
+      const mockSeqPosToVisibleCol = vi.fn().mockReturnValue(5)
+
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        connectedView: {
+          initialized: true,
+          assemblyNames: ['hg38'],
+        },
+        seqPosToVisibleCol: mockSeqPosToVisibleCol,
+      } as any
+
+      const result = genomeToMSA({ model })
+
+      // coord 1005 - start 1000 = ungapped position 5
+      expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('hg38.chr1', 5)
+      expect(result).toBe(5)
+    })
+
+    test('returns undefined when hover refName does not match mafRegion', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1005, refName: 'chr2' },
+        },
+      } as any)
+
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        connectedView: {
+          initialized: true,
+          assemblyNames: ['hg38'],
+        },
+        seqPosToVisibleCol: vi.fn(),
+      } as any
+
+      const result = genomeToMSA({ model })
+      expect(result).toBeUndefined()
+    })
+
+    test('returns undefined when hover coord is before mafRegion start', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 999, refName: 'chr1' },
+        },
+      } as any)
+
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        connectedView: {
+          initialized: true,
+          assemblyNames: ['hg38'],
+        },
+        seqPosToVisibleCol: vi.fn(),
+      } as any
+
+      const result = genomeToMSA({ model })
+      expect(result).toBeUndefined()
+    })
+
+    test('returns undefined when hover coord is at or after mafRegion end', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1010, refName: 'chr1' },
+        },
+      } as any)
+
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        connectedView: {
+          initialized: true,
+          assemblyNames: ['hg38'],
+        },
+        seqPosToVisibleCol: vi.fn(),
+      } as any
+
+      const result = genomeToMSA({ model })
+      expect(result).toBeUndefined()
+    })
+
+    test('returns undefined when assembly does not match', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1005, refName: 'chr1' },
+        },
+      } as any)
+
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        connectedView: {
+          initialized: true,
+          assemblyNames: ['mm39'], // Different assembly
+        },
+        seqPosToVisibleCol: vi.fn(),
+      } as any
+
+      const result = genomeToMSA({ model })
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('transcriptToMsaMap mapping (original behavior)', () => {
+    test('returns visible column using g2p mapping', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1005, refName: 'chr1' },
+        },
+      } as any)
+
+      const mockSeqPosToVisibleCol = vi.fn().mockReturnValue(10)
+
+      const model = {
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: {
+          g2p: { 1005: 10 },
+        },
+        mafRegion: undefined,
+        connectedView: { initialized: true },
+        seqPosToVisibleCol: mockSeqPosToVisibleCol,
+      } as any
+
+      const result = genomeToMSA({ model })
+
+      expect(mockSeqPosToVisibleCol).toHaveBeenCalledWith('QUERY', 10)
+      expect(result).toBe(10)
+    })
+
+    test('returns undefined when g2p has no mapping for coord', () => {
+      mockGetSession.mockReturnValue({
+        hovered: {
+          hoverFeature: {},
+          hoverPosition: { coord: 1005, refName: 'chr1' },
+        },
+      } as any)
+
+      const model = {
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: {
+          g2p: { 1000: 0 }, // No entry for 1005
+        },
+        mafRegion: undefined,
+        connectedView: { initialized: true },
+        seqPosToVisibleCol: vi.fn(),
+      } as any
+
+      const result = genomeToMSA({ model })
+      expect(result).toBeUndefined()
+    })
+  })
+
+  test('returns undefined when neither mafRegion nor transcriptToMsaMap is set', () => {
+    mockGetSession.mockReturnValue({
+      hovered: {
+        hoverFeature: {},
+        hoverPosition: { coord: 1005, refName: 'chr1' },
+      },
+    } as any)
+
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: undefined,
+      mafRegion: undefined,
+      connectedView: { initialized: true },
+      seqPosToVisibleCol: vi.fn(),
+    } as any
+
+    const result = genomeToMSA({ model })
+    expect(result).toBeUndefined()
+  })
+})

package/src/MsaViewPanel/genomeToMSA.ts

@@ -3,20 +3,53 @@ import { getSession } from '@jbrowse/core/util'
 import { JBrowsePluginMsaViewModel } from './model'
 import { checkHovered } from './util'
 
+/**
+ * Convert a genome coordinate from session.hovered to a visible MSA column.
+ *
+ * @param model - The MSA view model
+ * @returns The visible column index, or undefined if no mapping exists
+ */
 export function genomeToMSA({ model }: { model: JBrowsePluginMsaViewModel }) {
   const { hovered } = getSession(model)
-  const { querySeqName, transcriptToMsaMap, connectedView } = model
-  if (
-    connectedView?.initialized &&
-    transcriptToMsaMap &&
-    checkHovered(hovered)
-  ) {
-    const { coord: hoverCoord } = hovered.hoverPosition
+  const { querySeqName, transcriptToMsaMap, connectedView, mafRegion } = model
+
+  if (!connectedView?.initialized || !checkHovered(hovered)) {
+    return undefined
+  }
+
+  const { coord: hoverCoord, refName } = hovered.hoverPosition
+
+  // Handle MAF region mapping
+  if (mafRegion) {
+    // Check if the hover is on the same refName as the MAF region
+    if (refName !== mafRegion.refName) {
+      return undefined
+    }
+    // Check if we're on the same assembly (if assembly info is available)
+    const viewAssemblies = connectedView.assemblyNames
+    if (!viewAssemblies.includes(mafRegion.assemblyName)) {
+      return undefined
+    }
+    // Check if the hover coordinate is within the MAF region
+    if (hoverCoord < mafRegion.start || hoverCoord >= mafRegion.end) {
+      return undefined
+    }
+    // Calculate the ungapped position relative to the region start
+    const ungappedPos = hoverCoord - mafRegion.start
+    // Convert to visible column using the query sequence
+    return model.seqPosToVisibleCol(querySeqName, ungappedPos)
+  }
+
+  // Handle transcript mapping (original behavior)
+  if (transcriptToMsaMap) {
     const { g2p } = transcriptToMsaMap
-    const ret = g2p[hoverCoord]
-    if (ret !== undefined) {
-      return model.seqCoordToRowSpecificGlobalCoord(querySeqName, ret + 1)
+    // g2p maps genome coordinate to sequence position (0-based)
+    const seqPos = g2p[hoverCoord]
+    if (seqPos !== undefined) {
+      // Convert sequence position to visible column
+      return model.seqPosToVisibleCol(querySeqName, seqPos)
     }
   }
+
   return undefined
 }