jbrowse-plugin-msaview 2.2.3 → 2.2.5

package/src/MsaViewPanel/structureConnection.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  gappedToUngappedPosition,
+  mapToRecord,
+  ungappedToGappedPosition,
+} from './structureConnection'
+
+describe('gappedToUngappedPosition', () => {
+  test('returns correct ungapped position for non-gap character', () => {
+    const seq = 'M-KA-A'
+    //           0 12 34  (gapped positions)
+    //           0  1  2  (ungapped positions for M, K, A, A)
+    expect(gappedToUngappedPosition(seq, 0)).toBe(0) // M -> 0
+    expect(gappedToUngappedPosition(seq, 2)).toBe(1) // K -> 1
+    expect(gappedToUngappedPosition(seq, 3)).toBe(2) // A -> 2
+    expect(gappedToUngappedPosition(seq, 5)).toBe(3) // A -> 3
+  })
+
+  test('returns undefined for gap position', () => {
+    const seq = 'M-KA-A'
+    expect(gappedToUngappedPosition(seq, 1)).toBeUndefined() // gap
+    expect(gappedToUngappedPosition(seq, 4)).toBeUndefined() // gap
+  })
+
+  test('returns undefined for out-of-bounds position', () => {
+    const seq = 'MKA'
+    expect(gappedToUngappedPosition(seq, -1)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 3)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 100)).toBeUndefined()
+  })
+
+  test('handles sequence with no gaps', () => {
+    const seq = 'MKAA'
+    expect(gappedToUngappedPosition(seq, 0)).toBe(0)
+    expect(gappedToUngappedPosition(seq, 1)).toBe(1)
+    expect(gappedToUngappedPosition(seq, 2)).toBe(2)
+    expect(gappedToUngappedPosition(seq, 3)).toBe(3)
+  })
+
+  test('handles sequence with leading gaps', () => {
+    const seq = '--MKA'
+    expect(gappedToUngappedPosition(seq, 0)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 1)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 2)).toBe(0) // M
+    expect(gappedToUngappedPosition(seq, 3)).toBe(1) // K
+  })
+
+  test('handles sequence with trailing gaps', () => {
+    const seq = 'MKA--'
+    expect(gappedToUngappedPosition(seq, 2)).toBe(2) // A
+    expect(gappedToUngappedPosition(seq, 3)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 4)).toBeUndefined()
+  })
+
+  test('handles empty sequence', () => {
+    expect(gappedToUngappedPosition('', 0)).toBeUndefined()
+  })
+
+  test('handles all-gap sequence', () => {
+    const seq = '---'
+    expect(gappedToUngappedPosition(seq, 0)).toBeUndefined()
+    expect(gappedToUngappedPosition(seq, 1)).toBeUndefined()
+    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)
+      }
+    }
+  })
+})
+
+describe('mapToRecord', () => {
+  test('converts Map to Record', () => {
+    const map = new Map<number, number>([
+      [0, 5],
+      [1, 10],
+      [2, 15],
+    ])
+    const record = mapToRecord(map)
+    expect(record[0]).toBe(5)
+    expect(record[1]).toBe(10)
+    expect(record[2]).toBe(15)
+  })
+
+  test('handles empty Map', () => {
+    const map = new Map<number, number>()
+    const record = mapToRecord(map)
+    expect(Object.keys(record)).toHaveLength(0)
+  })
+})

package/src/MsaViewPanel/structureConnection.ts

@@ -0,0 +1,72 @@
+/**
+ * Represents a connection between the MSA view and a protein structure
+ */
+export interface StructureConnection {
+  /** ID of the ProteinView containing the structure */
+  proteinViewId: string
+  /** Index of the structure within the ProteinView's structures array */
+  structureIdx: number
+  /** Name of the MSA row that corresponds to this structure */
+  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 function gappedToUngappedPosition(
+  sequence: string,
+  gappedPosition: number,
+): number | undefined {
+  if (gappedPosition < 0 || gappedPosition >= sequence.length) {
+    return undefined
+  }
+
+  let ungapped = 0
+  for (let i = 0; i < gappedPosition; i++) {
+    if (sequence[i] !== '-') {
+      ungapped++
+    }
+  }
+
+  // If the position itself is a gap, return undefined
+  if (sequence[gappedPosition] === '-') {
+    return undefined
+  }
+
+  return ungapped
+}
+
+/**
+ * Helper to convert ungapped position to gapped MSA column for a specific row
+ */
+export function ungappedToGappedPosition(
+  sequence: string,
+  ungappedPosition: number,
+): number | undefined {
+  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
+}
+
+/**
+ * Convert Map to plain object for MST frozen storage
+ */
+export function mapToRecord(map: Map<number, number>): Record<number, number> {
+  const record: Record<number, number> = {}
+  for (const [key, value] of map) {
+    record[key] = value
+  }
+  return record
+}

package/src/MsaViewPanel/types.ts

@@ -0,0 +1,14 @@
+export interface MsaViewInitState {
+  msaData?: string
+  msaUrl?: string
+  treeData?: string
+  treeUrl?: string
+  querySeqName?: string
+}
+
+export interface MafRegion {
+  refName: string
+  start: number
+  end: number
+  assemblyName: string
+}

package/src/MsaViewPanel/util.ts

@@ -11,3 +11,14 @@ export function checkHovered(hovered: unknown): hovered is {
     'hoverPosition' in hovered
   )
 }
+
+/**
+ * Extracts UniProt ID from an AlphaFold URL
+ * Examples:
+ * - https://alphafold.ebi.ac.uk/files/AF-P12345-F1-model_v6.cif -> P12345
+ * - https://alphafold.ebi.ac.uk/files/msa/AF-P12345-F1-msa_v6.a3m -> P12345
+ */
+export function getUniprotIdFromAlphaFoldUrl(url: string) {
+  const match = /AF-([A-Z0-9]+)-F\d+/.exec(url)
+  return match?.[1]
+}

package/src/index.ts

@@ -2,13 +2,14 @@ import Plugin from '@jbrowse/core/Plugin'
 import PluginManager from '@jbrowse/core/PluginManager'
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 import { AbstractSessionModel, isAbstractMenuManager } from '@jbrowse/core/util'
+import { types } from '@jbrowse/mobx-state-tree'
 import GridOn from '@mui/icons-material/GridOn'
-import { types } from 'mobx-state-tree'
 
 import { version } from '../package.json'
 import AddHighlightModelF from './AddHighlightModel'
 import BgzipFastaMsaAdapterF from './BgzipFastaMsaAdapter'
 import LaunchMsaViewF from './LaunchMsaView'
+import LaunchMsaViewExtensionPointF from './LaunchMsaViewExtensionPoint'
 import MsaViewF from './MsaViewPanel'
 
 export default class MsaViewPlugin extends Plugin {
@@ -18,6 +19,7 @@ export default class MsaViewPlugin extends Plugin {
   install(pluginManager: PluginManager) {
     MsaViewF(pluginManager)
     LaunchMsaViewF(pluginManager)
+    LaunchMsaViewExtensionPointF(pluginManager)
     AddHighlightModelF(pluginManager)
     BgzipFastaMsaAdapterF(pluginManager)
   }

package/src/utils/blastCache.ts

@@ -0,0 +1,114 @@
+import { openDB } from 'idb'
+
+const DB_NAME = 'jbrowse-msaview-blast-cache'
+const STORE_NAME = 'blast-results'
+const DB_VERSION = 2
+
+export interface CachedBlastResult {
+  id: string
+  proteinSequence: string
+  blastDatabase: string
+  blastProgram: string
+  msaAlgorithm: string
+  msa: string
+  tree: string
+  treeMetadata: string
+  rid: string
+  timestamp: number
+  geneId?: string
+  transcriptId?: string
+}
+
+async function getDB() {
+  return openDB(DB_NAME, DB_VERSION, {
+    upgrade(db, oldVersion) {
+      if (oldVersion < 2 && db.objectStoreNames.contains(STORE_NAME)) {
+        db.deleteObjectStore(STORE_NAME)
+      }
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'id' })
+      }
+    },
+  })
+}
+
+function createCacheKey(
+  proteinSequence: string,
+  blastDatabase: string,
+  blastProgram: string,
+) {
+  return `${blastDatabase}:${blastProgram}:${proteinSequence.slice(0, 100)}`
+}
+
+export async function getCachedBlastResult({
+  proteinSequence,
+  blastDatabase,
+  blastProgram,
+}: {
+  proteinSequence: string
+  blastDatabase: string
+  blastProgram: string
+}) {
+  const db = await getDB()
+  const id = createCacheKey(proteinSequence, blastDatabase, blastProgram)
+  return db.get(STORE_NAME, id)
+}
+
+export async function saveBlastResult({
+  proteinSequence,
+  blastDatabase,
+  blastProgram,
+  msaAlgorithm,
+  msa,
+  tree,
+  treeMetadata,
+  rid,
+  geneId,
+  transcriptId,
+}: {
+  proteinSequence: string
+  blastDatabase: string
+  blastProgram: string
+  msaAlgorithm: string
+  msa: string
+  tree: string
+  treeMetadata: string
+  rid: string
+  geneId?: string
+  transcriptId?: string
+}) {
+  const db = await getDB()
+  const id = createCacheKey(proteinSequence, blastDatabase, blastProgram)
+  const entry: CachedBlastResult = {
+    id,
+    proteinSequence,
+    blastDatabase,
+    blastProgram,
+    msaAlgorithm,
+    msa,
+    tree,
+    treeMetadata,
+    rid,
+    timestamp: Date.now(),
+    geneId,
+    transcriptId,
+  }
+  await db.put(STORE_NAME, entry)
+  return entry
+}
+
+export async function getAllCachedResults() {
+  const db = await getDB()
+  const results = await db.getAll(STORE_NAME)
+  return results.toSorted((a, b) => b.timestamp - a.timestamp)
+}
+
+export async function deleteCachedResult(id: string) {
+  const db = await getDB()
+  await db.delete(STORE_NAME, id)
+}
+
+export async function clearAllCachedResults() {
+  const db = await getDB()
+  await db.clear(STORE_NAME)
+}

package/src/utils/fetch.ts

@@ -1,4 +1,4 @@
-import { ungzip } from 'pako'
+import { ungzip } from 'pako-esm2'
 
 export async function handleFetch(url: string, args?: RequestInit) {
   const response = await fetch(url, args)

package/src/utils/taxonomyNames.ts

@@ -0,0 +1,111 @@
+import { openDB } from 'idb'
+
+const DB_NAME = 'jbrowse-msaview-taxonomy-cache'
+const STORE_NAME = 'common-names'
+const DB_VERSION = 1
+
+interface CachedTaxonomy {
+  taxid: number
+  sciname: string
+  commonName?: string
+}
+
+async function getDB() {
+  return openDB(DB_NAME, DB_VERSION, {
+    upgrade(db) {
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'taxid' })
+      }
+    },
+  })
+}
+
+async function getCachedCommonName(taxid: number) {
+  const db = await getDB()
+  return db.get(STORE_NAME, taxid) as Promise<CachedTaxonomy | undefined>
+}
+
+async function saveTaxonomyCache(entries: CachedTaxonomy[]) {
+  const db = await getDB()
+  const tx = db.transaction(STORE_NAME, 'readwrite')
+  for (const entry of entries) {
+    await tx.store.put(entry)
+  }
+  await tx.done
+}
+
+export interface TaxonomyInfo {
+  sciname: string
+  commonName?: string
+}
+
+export async function fetchTaxonomyInfo(
+  taxids: number[],
+): Promise<Map<number, TaxonomyInfo>> {
+  const result = new Map<number, TaxonomyInfo>()
+  const uncachedTaxids: number[] = []
+
+  for (const taxid of taxids) {
+    const cached = await getCachedCommonName(taxid)
+    if (cached) {
+      result.set(taxid, {
+        sciname: cached.sciname,
+        commonName: cached.commonName,
+      })
+    } else {
+      uncachedTaxids.push(taxid)
+    }
+  }
+
+  if (uncachedTaxids.length === 0) {
+    return result
+  }
+
+  const batchSize = 100
+  const toCache: CachedTaxonomy[] = []
+
+  for (let i = 0; i < uncachedTaxids.length; i += batchSize) {
+    const batch = uncachedTaxids.slice(i, i + batchSize)
+    const idsParam = batch.join(',')
+
+    try {
+      const response = await fetch(
+        `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=taxonomy&id=${idsParam}&retmode=xml`,
+      )
+      const text = await response.text()
+
+      for (const taxid of batch) {
+        const taxonRegex = new RegExp(
+          `<Taxon>.*?<TaxId>${taxid}</TaxId>.*?</Taxon>`,
+          's',
+        )
+        const taxonMatch = taxonRegex.exec(text)
+
+        if (taxonMatch) {
+          const taxonXml = taxonMatch[0]
+          const genbankCommon =
+            /<GenbankCommonName>(.*?)<\/GenbankCommonName>/.exec(taxonXml)
+          const commonName = /<CommonName>(.*?)<\/CommonName>/.exec(taxonXml)
+          const sciName = /<ScientificName>(.*?)<\/ScientificName>/.exec(
+            taxonXml,
+          )
+          const name = genbankCommon?.[1] ?? commonName?.[1]
+
+          const sci = sciName?.[1] ?? ''
+          result.set(taxid, { sciname: sci, commonName: name })
+          toCache.push({ taxid, sciname: sci, commonName: name })
+        } else {
+          toCache.push({ taxid, sciname: '', commonName: undefined })
+        }
+      }
+    } catch (error) {
+      console.error('Failed to fetch taxonomy data:', error)
+    }
+  }
+
+  if (toCache.length > 0) {
+    await saveTaxonomyCache(toCache)
+  }
+
+  return result
+}

package/src/utils/types.ts

@@ -1,10 +1,18 @@
+export interface BlastHitDescription {
+  accession: string
+  id: string
+  sciname: string
+  taxid?: number
+  title?: string
+}
+
 export interface BlastResults {
   BlastOutput2: {
     report: {
       results: {
         search: {
           hits: {
-            description: { accession: string; id: string; sciname: string }[]
+            description: BlastHitDescription[]
             hsps: { hseq: string }[]
           }[]
         }

package/dist/LaunchMsaView/components/PreLoadedMSA/findValidTranscriptId.d.ts

@@ -1,5 +0,0 @@
-import type { Feature } from '@jbrowse/core/util';
-export declare function findValidTranscriptId({ transcriptsList, validMsaList, }: {
-    transcriptsList: Feature[];
-    validMsaList?: string[];
-}): string | null;

package/dist/LaunchMsaView/components/PreLoadedMSA/findValidTranscriptId.js

@@ -1,16 +0,0 @@
-import { getId } from '../../util';
-// Function to find a valid transcript ID that exists in the MSA list
-export function findValidTranscriptId({ transcriptsList, validMsaList, }) {
-    if (!validMsaList || validMsaList.length === 0) {
-        return null;
-    }
-    // Try to find a transcript ID that exists in the MSA list
-    for (const transcript of transcriptsList) {
-        const id = getId(transcript);
-        if (id && validMsaList.includes(id)) {
-            return id;
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=findValidTranscriptId.js.map

package/dist/LaunchMsaView/components/PreLoadedMSA/findValidTranscriptId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"findValidTranscriptId.js","sourceRoot":"","sources":["../../../../src/LaunchMsaView/components/PreLoadedMSA/findValidTranscriptId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAIlC,qEAAqE;AACrE,MAAM,UAAU,qBAAqB,CAAC,EACpC,eAAe,EACf,YAAY,GAIb;IACC,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/C,OAAO,IAAI,CAAA;IACb,CAAC;IAED,0DAA0D;IAC1D,KAAK,MAAM,UAAU,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,CAAA;QAC5B,IAAI,EAAE,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YACpC,OAAO,EAAE,CAAA;QACX,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}