jbrowse-plugin-msaview 2.2.3 → 2.2.5

package/src/MsaViewPanel/msaCoordToGenomeCoord.test.ts

@@ -0,0 +1,256 @@
+import { describe, expect, test } from 'vitest'
+
+import { msaCoordToGenomeCoord } from './msaCoordToGenomeCoord'
+
+describe('msaCoordToGenomeCoord', () => {
+  test('returns undefined when neither transcriptToMsaMap nor mafRegion is defined', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: undefined,
+      mafRegion: undefined,
+      rows: [['QUERY', 'MKAA']],
+    }
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toBeUndefined()
+  })
+
+  test('returns undefined when query row is not found', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100, 1: 103 },
+      },
+      rows: [['OTHER', 'MKAA']],
+    }
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toBeUndefined()
+  })
+
+  test('returns undefined when coord is a gap', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100, 1: 103 },
+      },
+      rows: [['QUERY', 'M-KA']],
+    }
+    // Position 1 is a gap
+    const result = msaCoordToGenomeCoord({ model, coord: 1 })
+    expect(result).toBeUndefined()
+  })
+
+  test('returns genome region for valid non-gap position', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100, 1: 103, 2: 106, 3: 109 },
+      },
+      rows: [['QUERY', 'MKAA']],
+    }
+    // Position 0 (M) should map to ungapped 0, genome 100-103
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toEqual({
+      refName: 'chr1',
+      start: 100,
+      end: 103,
+    })
+  })
+
+  test('handles gapped sequence correctly', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100, 1: 103, 2: 106, 3: 109 },
+      },
+      rows: [['QUERY', 'M-K-AA']],
+      //                 012345 gapped positions
+      //                 0  1 23 ungapped positions
+    }
+    // Gapped position 2 (K) = ungapped 1
+    const result = msaCoordToGenomeCoord({ model, coord: 2 })
+    expect(result).toEqual({
+      refName: 'chr1',
+      start: 103,
+      end: 106,
+    })
+
+    // Gapped position 4 (first A) = ungapped 2
+    const result2 = msaCoordToGenomeCoord({ model, coord: 4 })
+    expect(result2).toEqual({
+      refName: 'chr1',
+      start: 106,
+      end: 109,
+    })
+  })
+
+  test('returns undefined when p2g mapping is incomplete', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100 }, // Missing entry for position 1
+      },
+      rows: [['QUERY', 'MKAA']],
+    }
+    // Position 0 needs p2g[0] and p2g[1], but p2g[1] is missing
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toBeUndefined()
+  })
+
+  test('handles reverse strand (start > end in p2g)', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 109, 1: 106, 2: 103, 3: 100 }, // Reverse strand
+      },
+      rows: [['QUERY', 'MKAA']],
+    }
+    // Should return min/max correctly
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toEqual({
+      refName: 'chr1',
+      start: 106, // min(109, 106)
+      end: 109, // max(109, 106)
+    })
+  })
+
+  test('returns undefined for out of bounds coord', () => {
+    const model = {
+      querySeqName: 'QUERY',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 100, 1: 103 },
+      },
+      rows: [['QUERY', 'MK']],
+    }
+    // Position 10 is out of bounds
+    const result = msaCoordToGenomeCoord({ model, coord: 10 })
+    expect(result).toBeUndefined()
+  })
+
+  test('works with multiple rows, uses querySeqName', () => {
+    const model = {
+      querySeqName: 'SEQ2',
+      transcriptToMsaMap: {
+        refName: 'chr1',
+        p2g: { 0: 200, 1: 203 },
+      },
+      rows: [
+        ['SEQ1', 'AAAA'],
+        ['SEQ2', 'MKAA'],
+        ['SEQ3', 'LLLL'],
+      ],
+    }
+    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    expect(result).toEqual({
+      refName: 'chr1',
+      start: 200,
+      end: 203,
+    })
+  })
+
+  // MAF region tests
+  describe('mafRegion', () => {
+    test('returns genome position for mafRegion mapping', () => {
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        rows: [['hg38.chr1', 'ACGTACGTAC']],
+      }
+      // Position 0 should map to genome 1000
+      const result = msaCoordToGenomeCoord({ model, coord: 0 })
+      expect(result).toEqual({
+        refName: 'chr1',
+        start: 1000,
+        end: 1001,
+      })
+
+      // Position 5 should map to genome 1005
+      const result2 = msaCoordToGenomeCoord({ model, coord: 5 })
+      expect(result2).toEqual({
+        refName: 'chr1',
+        start: 1005,
+        end: 1006,
+      })
+    })
+
+    test('handles gaps in mafRegion sequence', () => {
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1008,
+          assemblyName: 'hg38',
+        },
+        rows: [['hg38.chr1', 'AC--GTAC']],
+        // Gapped positions: 0  1  2  3  4  5  6  7
+        // Ungapped:         0  1        2  3  4  5
+      }
+      // Position 2 is a gap, should return undefined
+      const result = msaCoordToGenomeCoord({ model, coord: 2 })
+      expect(result).toBeUndefined()
+
+      // Position 4 (G) = ungapped 2 = genome 1002
+      const result2 = msaCoordToGenomeCoord({ model, coord: 4 })
+      expect(result2).toEqual({
+        refName: 'chr1',
+        start: 1002,
+        end: 1003,
+      })
+    })
+
+    test('returns undefined when position exceeds mafRegion end', () => {
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: undefined,
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1005,
+          assemblyName: 'hg38',
+        },
+        rows: [['hg38.chr1', 'ACGTACGTAC']], // 10 chars but region is only 5bp
+      }
+      // Position 8 would be ungapped 8 = genome 1008, but region ends at 1005
+      const result = msaCoordToGenomeCoord({ model, coord: 8 })
+      expect(result).toBeUndefined()
+    })
+
+    test('mafRegion takes precedence over transcriptToMsaMap', () => {
+      const model = {
+        querySeqName: 'hg38.chr1',
+        transcriptToMsaMap: {
+          refName: 'chr2',
+          p2g: { 0: 5000, 1: 5003 },
+        },
+        mafRegion: {
+          refName: 'chr1',
+          start: 1000,
+          end: 1010,
+          assemblyName: 'hg38',
+        },
+        rows: [['hg38.chr1', 'ACGTACGTAC']],
+      }
+      // Should use mafRegion, not transcriptToMsaMap
+      const result = msaCoordToGenomeCoord({ model, coord: 0 })
+      expect(result).toEqual({
+        refName: 'chr1',
+        start: 1000,
+        end: 1001,
+      })
+    })
+  })
+})

package/src/MsaViewPanel/msaCoordToGenomeCoord.ts

@@ -1,44 +1,56 @@
-/**
- * Convert gapped MSA column coordinate to ungapped sequence coordinate
- * This is the inverse of ungappedCoordMap
- */
-function gappedToUngappedCoord(seq: string, gappedPos: number): number {
-  let ungappedPos = 0
-  for (let i = 0; i < gappedPos && i < seq.length; i++) {
-    if (seq[i] !== '-') {
-      ungappedPos++
-    }
-  }
-  return ungappedPos
-}
+import { gappedToUngappedPosition } from './structureConnection'
+
+import type { MafRegion } from './types'
 
 export function msaCoordToGenomeCoord({
   model,
   coord: mouseCol,
 }: {
-  model: { querySeqName: string; transcriptToMsaMap: any; rows: string[][] }
+  model: {
+    querySeqName: string
+    transcriptToMsaMap:
+      | {
+          refName: string
+          p2g: Record<number, number>
+        }
+      | undefined
+    mafRegion?: MafRegion
+    rows: string[][]
+  }
   coord: number
 }) {
-  const { querySeqName, transcriptToMsaMap } = model
-  if (transcriptToMsaMap === undefined) {
+  const { querySeqName, transcriptToMsaMap, mafRegion } = model
+
+  // Get the query sequence
+  const queryRow = model.rows.find(f => f[0] === querySeqName)
+  const querySeq = queryRow?.[1]
+  if (!querySeq) {
     return undefined
-  } else {
-    // Get the query sequence
-    const queryRow = model.rows.find(f => f[0] === querySeqName)
-    const querySeq = queryRow?.[1]
-    if (!querySeq) {
-      return undefined
-    }
+  }
+
+  // Convert gapped MSA column to ungapped sequence coordinate
+  // Returns undefined if the position is a gap
+  const ungappedPos = gappedToUngappedPosition(querySeq, mouseCol)
+  if (ungappedPos === undefined) {
+    return undefined
+  }
 
-    // Check if the position in the query sequence is a gap
-    if (querySeq[mouseCol] === '-') {
+  // Handle MAF region mapping
+  if (mafRegion) {
+    const genomePos = mafRegion.start + ungappedPos
+    // Check if position is within the region
+    if (genomePos >= mafRegion.end) {
       return undefined
     }
+    return {
+      refName: mafRegion.refName,
+      start: genomePos,
+      end: genomePos + 1,
+    }
+  }
 
-    // Convert gapped MSA column to ungapped sequence coordinate
-    const ungappedPos = gappedToUngappedCoord(querySeq, mouseCol)
-
-    // Use the ungapped position to look up in the p2g map
+  // Handle transcript mapping (original behavior)
+  if (transcriptToMsaMap) {
     const { refName, p2g } = transcriptToMsaMap
     const s = p2g[ungappedPos]
     const e = p2g[ungappedPos + 1]
@@ -50,4 +62,6 @@ export function msaCoordToGenomeCoord({
         }
       : undefined
   }
+
+  return undefined
 }

package/src/MsaViewPanel/msaDataStore.ts

@@ -0,0 +1,236 @@
+const DB_NAME = 'jbrowse-msaview-data'
+const DB_VERSION = 1
+const STORE_NAME = 'msa-data'
+
+interface StoredMsaData {
+  id: string
+  msa?: string
+  tree?: string
+  treeMetadata?: string
+  timestamp: number
+}
+
+let dbPromise: Promise<IDBDatabase | undefined> | undefined
+let indexedDBAvailable: boolean | undefined
+
+function checkIndexedDBAvailable(): boolean {
+  if (indexedDBAvailable !== undefined) {
+    return indexedDBAvailable
+  }
+
+  try {
+    // Check if indexedDB exists and is accessible
+    if (typeof indexedDB === 'undefined') {
+      indexedDBAvailable = false
+      return false
+    }
+
+    // Try to open a test database to verify IndexedDB is working
+    // This can fail in private browsing mode in some browsers
+    indexedDBAvailable = true
+    return true
+  } catch {
+    indexedDBAvailable = false
+    return false
+  }
+}
+
+async function openDB(): Promise<IDBDatabase | undefined> {
+  if (!checkIndexedDBAvailable()) {
+    return undefined
+  }
+
+  if (dbPromise) {
+    return dbPromise
+  }
+
+  dbPromise = new Promise(resolve => {
+    try {
+      const request = indexedDB.open(DB_NAME, DB_VERSION)
+
+      request.addEventListener('error', () => {
+        // IndexedDB may be blocked in private browsing mode
+        console.warn(
+          'IndexedDB unavailable - MSA data will not persist across page refreshes',
+        )
+        indexedDBAvailable = false
+        resolve(undefined)
+      })
+
+      request.onsuccess = () => {
+        resolve(request.result)
+      }
+
+      request.onupgradeneeded = event => {
+        const db = (event.target as IDBOpenDBRequest).result
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' })
+          store.createIndex('timestamp', 'timestamp', { unique: false })
+        }
+      }
+    } catch (e) {
+      console.warn('Failed to open IndexedDB:', e)
+      indexedDBAvailable = false
+      resolve(undefined)
+    }
+  })
+
+  return dbPromise
+}
+
+export function generateDataStoreId() {
+  return `msa-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
+}
+
+export async function storeMsaData(
+  id: string,
+  data: { msa?: string; tree?: string; treeMetadata?: string },
+): Promise<boolean> {
+  const db = await openDB()
+  if (!db) {
+    // IndexedDB not available, silently skip storage
+    return false
+  }
+
+  return new Promise<boolean>(resolve => {
+    try {
+      const transaction = db.transaction(STORE_NAME, 'readwrite')
+      const store = transaction.objectStore(STORE_NAME)
+
+      const storedData: StoredMsaData = {
+        id,
+        msa: data.msa,
+        tree: data.tree,
+        treeMetadata: data.treeMetadata,
+        timestamp: Date.now(),
+      }
+
+      const request = store.put(storedData)
+
+      request.addEventListener('error', () => {
+        // Log but don't fail - storage is best-effort
+        console.warn('Failed to store MSA data:', request.error)
+        resolve(false)
+      })
+
+      request.onsuccess = () => {
+        resolve(true)
+      }
+    } catch (e) {
+      console.warn('Failed to store MSA data:', e)
+      resolve(false)
+    }
+  })
+}
+
+export async function retrieveMsaData(
+  id: string,
+): Promise<{ msa?: string; tree?: string; treeMetadata?: string } | undefined> {
+  const db = await openDB()
+  if (!db) {
+    return undefined
+  }
+
+  return new Promise(resolve => {
+    try {
+      const transaction = db.transaction(STORE_NAME, 'readonly')
+      const store = transaction.objectStore(STORE_NAME)
+      const request = store.get(id)
+
+      request.addEventListener('error', () => {
+        console.warn('Failed to retrieve MSA data:', request.error)
+        resolve(undefined)
+      })
+
+      request.onsuccess = () => {
+        const result = request.result as StoredMsaData | undefined
+        if (result) {
+          resolve({
+            msa: result.msa,
+            tree: result.tree,
+            treeMetadata: result.treeMetadata,
+          })
+        } else {
+          resolve(undefined)
+        }
+      }
+    } catch (e) {
+      console.warn('Failed to retrieve MSA data:', e)
+      resolve(undefined)
+    }
+  })
+}
+
+export async function deleteMsaData(id: string) {
+  const db = await openDB()
+  if (!db) {
+    return
+  }
+
+  return new Promise<void>(resolve => {
+    try {
+      const transaction = db.transaction(STORE_NAME, 'readwrite')
+      const store = transaction.objectStore(STORE_NAME)
+      const request = store.delete(id)
+
+      request.addEventListener('error', () => {
+        console.warn('Failed to delete MSA data:', request.error)
+        resolve()
+      })
+
+      request.onsuccess = () => {
+        resolve()
+      }
+    } catch (e) {
+      console.warn('Failed to delete MSA data:', e)
+      resolve()
+    }
+  })
+}
+
+// Clean up entries older than the specified age (default 7 days)
+export async function cleanupOldData(maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
+  const db = await openDB()
+  if (!db) {
+    return 0
+  }
+
+  const cutoffTime = Date.now() - maxAgeMs
+
+  return new Promise<number>(resolve => {
+    try {
+      const transaction = db.transaction(STORE_NAME, 'readwrite')
+      const store = transaction.objectStore(STORE_NAME)
+      const index = store.index('timestamp')
+      const range = IDBKeyRange.upperBound(cutoffTime)
+      const request = index.openCursor(range)
+
+      let deletedCount = 0
+
+      request.addEventListener('error', () => {
+        console.warn('Failed to cleanup old MSA data:', request.error)
+        resolve(deletedCount)
+      })
+
+      request.onsuccess = event => {
+        const cursor = (event.target as IDBRequest<IDBCursorWithValue | null>)
+          .result
+        if (cursor) {
+          cursor.delete()
+          deletedCount++
+          cursor.continue()
+        } else {
+          resolve(deletedCount)
+        }
+      }
+    } catch (e) {
+      console.warn('Failed to cleanup old MSA data:', e)
+      resolve(0)
+    }
+  })
+}
+
+// Check if IndexedDB storage is available
+export function isIndexedDBAvailable() {
+  return checkIndexedDBAvailable()
+}