jbrowse-plugin-msaview 2.7.2 → 2.7.4

package/src/MsaViewPanel/msaCoordToGenomeCoord.test.ts

@@ -1,6 +1,21 @@
+import { genomeToTranscriptSeqMapping } from 'g2p_mapper'
 import { describe, expect, test } from 'vitest'
 
-import { msaCoordToGenomeCoord } from './msaCoordToGenomeCoord'
+import {
+  msaCoordToGenomeCoord,
+  msaCoordToGenomeRegions,
+} from './msaCoordToGenomeCoord'
+
+// codon at protein position i covers three consecutive genome bases starting at
+// 100 + i * 3, i.e. a single-exon forward-strand transcript
+function forwardCodons(n: number) {
+  return Object.fromEntries(
+    Array.from({ length: n }, (_, i) => [
+      i,
+      [100 + i * 3, 101 + i * 3, 102 + i * 3],
+    ]),
+  )
+}
 
 describe('msaCoordToGenomeCoord', () => {
   test('returns undefined when neither transcriptToMsaMap nor mafRegion is defined', () => {
@@ -19,7 +34,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100, 1: 103 },
+        p2gCodon: forwardCodons(2),
       },
       rows: [['OTHER', 'MKAA']],
     }
@@ -32,7 +47,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100, 1: 103 },
+        p2gCodon: forwardCodons(2),
       },
       rows: [['QUERY', 'M-KA']],
     }
@@ -46,7 +61,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100, 1: 103, 2: 106, 3: 109 },
+        p2gCodon: forwardCodons(4),
       },
       rows: [['QUERY', 'MKAA']],
     }
@@ -64,7 +79,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100, 1: 103, 2: 106, 3: 109 },
+        p2gCodon: forwardCodons(4),
       },
       rows: [['QUERY', 'M-K-AA']],
       //                 012345 gapped positions
@@ -87,35 +102,34 @@ describe('msaCoordToGenomeCoord', () => {
     })
   })
 
-  test('returns undefined when p2g mapping is incomplete', () => {
+  test('returns undefined when the position has no codon mapping', () => {
     const model = {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100 }, // Missing entry for position 1
+        p2gCodon: forwardCodons(1),
       },
       rows: [['QUERY', 'MKAA']],
     }
-    // Position 0 needs p2g[0] and p2g[1], but p2g[1] is missing
-    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    // ungapped position 1 has no entry in p2gCodon
+    const result = msaCoordToGenomeCoord({ model, coord: 1 })
     expect(result).toBeUndefined()
   })
 
-  test('handles reverse strand (start > end in p2g)', () => {
+  test('maps the final residue, whose codon has no successor', () => {
     const model = {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 109, 1: 106, 2: 103, 3: 100 }, // Reverse strand
+        p2gCodon: forwardCodons(4),
       },
       rows: [['QUERY', 'MKAA']],
     }
-    // Should return min/max correctly
-    const result = msaCoordToGenomeCoord({ model, coord: 0 })
+    const result = msaCoordToGenomeCoord({ model, coord: 3 })
     expect(result).toEqual({
       refName: 'chr1',
-      start: 106, // min(109, 106)
-      end: 109, // max(109, 106)
+      start: 109,
+      end: 112,
     })
   })
 
@@ -124,7 +138,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'QUERY',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 100, 1: 103 },
+        p2gCodon: forwardCodons(2),
       },
       rows: [['QUERY', 'MK']],
     }
@@ -138,7 +152,7 @@ describe('msaCoordToGenomeCoord', () => {
       querySeqName: 'SEQ2',
       transcriptToMsaMap: {
         refName: 'chr1',
-        p2g: { 0: 200, 1: 203 },
+        p2gCodon: { 0: [200, 201, 202], 1: [203, 204, 205] },
       },
       rows: [
         ['SEQ1', 'AAAA'],
@@ -154,6 +168,91 @@ describe('msaCoordToGenomeCoord', () => {
     })
   })
 
+  // The mapping comes from the real g2p_mapper rather than hand-written
+  // fixtures: on the reverse strand p2g stores the codon's *highest*
+  // coordinate, which is what the old p2g[pos]..p2g[pos+1] arithmetic got wrong
+  describe('real g2p_mapper mappings', () => {
+    test('forward strand, single exon', () => {
+      const { p2gCodon, refName } = genomeToTranscriptSeqMapping({
+        refName: 'chr1',
+        start: 100,
+        end: 112,
+        strand: 1,
+        subfeatures: [{ refName: 'chr1', type: 'CDS', start: 100, end: 112 }],
+      })
+      const model = {
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: { refName, p2gCodon },
+        rows: [['QUERY', 'MKAA']],
+      }
+      expect(msaCoordToGenomeCoord({ model, coord: 0 })).toEqual({
+        refName: 'chr1',
+        start: 100,
+        end: 103,
+      })
+      expect(msaCoordToGenomeCoord({ model, coord: 3 })).toEqual({
+        refName: 'chr1',
+        start: 109,
+        end: 112,
+      })
+    })
+
+    test('reverse strand codon covers the last three bases of the CDS', () => {
+      const { p2gCodon, refName } = genomeToTranscriptSeqMapping({
+        refName: 'chr1',
+        start: 100,
+        end: 112,
+        strand: -1,
+        subfeatures: [{ refName: 'chr1', type: 'CDS', start: 100, end: 112 }],
+      })
+      const model = {
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: { refName, p2gCodon },
+        rows: [['QUERY', 'MKAA']],
+      }
+      // the first residue is translated from the 3' end of the genome region
+      expect(msaCoordToGenomeCoord({ model, coord: 0 })).toEqual({
+        refName: 'chr1',
+        start: 109,
+        end: 112,
+      })
+      expect(msaCoordToGenomeCoord({ model, coord: 3 })).toEqual({
+        refName: 'chr1',
+        start: 100,
+        end: 103,
+      })
+    })
+
+    test('codon split across an exon boundary yields one region per piece', () => {
+      // exon 1 contributes 4 bases, so residue 1 straddles the intron
+      const { p2gCodon, refName } = genomeToTranscriptSeqMapping({
+        refName: 'chr1',
+        start: 100,
+        end: 210,
+        strand: 1,
+        subfeatures: [
+          { refName: 'chr1', type: 'CDS', start: 100, end: 104 },
+          { refName: 'chr1', type: 'CDS', start: 200, end: 202 },
+        ],
+      })
+      const model = {
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: { refName, p2gCodon },
+        rows: [['QUERY', 'MK']],
+      }
+      expect(msaCoordToGenomeRegions({ model, coord: 1 })).toEqual([
+        { refName: 'chr1', start: 103, end: 104 },
+        { refName: 'chr1', start: 200, end: 202 },
+      ])
+      // the single-region form bounds the pieces, for navigation
+      expect(msaCoordToGenomeCoord({ model, coord: 1 })).toEqual({
+        refName: 'chr1',
+        start: 103,
+        end: 202,
+      })
+    })
+  })
+
   // MAF region tests
   describe('mafRegion', () => {
     test('returns genome position for mafRegion mapping', () => {
@@ -234,7 +333,7 @@ describe('msaCoordToGenomeCoord', () => {
         querySeqName: 'hg38.chr1',
         transcriptToMsaMap: {
           refName: 'chr2',
-          p2g: { 0: 5000, 1: 5003 },
+          p2gCodon: { 0: [5000, 5001, 5002], 1: [5003, 5004, 5005] },
         },
         mafRegion: {
           refName: 'chr1',

package/src/MsaViewPanel/msaCoordToGenomeCoord.ts

@@ -1,51 +1,95 @@
+import { getCodonRanges } from 'g2p_mapper'
+
 import { gappedToUngappedPosition } from './structureConnection'
 
 import type { MafRegion } from './types'
 
-export function msaCoordToGenomeCoord({
+interface GenomeRegion {
+  refName: string
+  start: number
+  end: number
+}
+
+interface CoordModel {
+  querySeqName: string
+  transcriptToMsaMap:
+    | {
+        refName: string
+        p2gCodon: Record<number, number[]>
+      }
+    | undefined
+  mafRegion?: MafRegion
+  rows: string[][]
+}
+
+/**
+ * The genome regions covered by MSA column `coord` of the query row, in 0-based
+ * half-open coordinates (what bpToPx and navTo take).
+ *
+ * Usually one region -- one codon, or one base in a MAF alignment -- but a
+ * codon split across an exon boundary yields one region per contiguous piece,
+ * which is why this returns a list.
+ */
+export function msaCoordToGenomeRegions({
   model,
   coord: mouseCol,
 }: {
-  model: {
-    querySeqName: string
-    transcriptToMsaMap:
-      | {
-          refName: string
-          p2g: Record<number, number>
-        }
-      | undefined
-    mafRegion?: MafRegion
-    rows: string[][]
-  }
+  model: CoordModel
   coord: number
-}) {
-  const { querySeqName, transcriptToMsaMap, mafRegion } = model
+}): GenomeRegion[] {
+  const { querySeqName, transcriptToMsaMap, mafRegion, rows } = model
 
-  const querySeq = model.rows.find(f => f[0] === querySeqName)?.[1]
+  const querySeq = rows.find(f => f[0] === querySeqName)?.[1]
   if (!querySeq) {
-    return undefined
+    return []
   }
 
   const ungappedPos = gappedToUngappedPosition(querySeq, mouseCol)
   if (ungappedPos === undefined) {
-    return undefined
+    return []
   }
 
   if (mafRegion) {
     const genomePos = mafRegion.start + ungappedPos
     return genomePos < mafRegion.end
-      ? { refName: mafRegion.refName, start: genomePos, end: genomePos + 1 }
-      : undefined
+      ? [{ refName: mafRegion.refName, start: genomePos, end: genomePos + 1 }]
+      : []
   }
 
   if (transcriptToMsaMap) {
-    const { refName, p2g } = transcriptToMsaMap
-    const s = p2g[ungappedPos]
-    const e = p2g[ungappedPos + 1]
-    return s !== undefined && e !== undefined
-      ? { refName, start: Math.min(s, e), end: Math.max(s, e) }
-      : undefined
+    const { refName, p2gCodon } = transcriptToMsaMap
+    // p2gCodon holds every genomic base of the codon, so the range is exact on
+    // either strand. Deriving it from consecutive p2g entries instead
+    // (p2g[pos]..p2g[pos+1]) was off by one base on the reverse strand -- where
+    // p2g stores the codon's *highest* coordinate -- dropped the final residue,
+    // whose successor has no p2g entry, and spanned the whole intron for a
+    // codon split across an exon boundary.
+    return (
+      getCodonRanges(p2gCodon, ungappedPos)?.map(([start, end]) => ({
+        refName,
+        start,
+        end,
+      })) ?? []
+    )
   }
 
-  return undefined
+  return []
+}
+
+/**
+ * A single region spanning the codon at MSA column `coord`, for navigation. For
+ * a codon split across an exon boundary this spans the intervening intron.
+ */
+export function msaCoordToGenomeCoord(args: {
+  model: CoordModel
+  coord: number
+}): GenomeRegion | undefined {
+  const regions = msaCoordToGenomeRegions(args)
+  const first = regions[0]
+  const last = regions.at(-1)
+  // getCodonRanges returns ranges sorted ascending, so first.start..last.end
+  // bounds the codon
+  return first && last
+    ? { refName: first.refName, start: first.start, end: last.end }
+    : undefined
 }

package/src/MsaViewPanel/msaDataStore.ts

@@ -1,4 +1,6 @@
-import { openDB } from 'idb'
+import { createDbOpener } from '../utils/idb'
+
+import type { DBSchema } from 'idb'
 
 const DB_NAME = 'jbrowse-msaview-data'
 const DB_VERSION = 1
@@ -12,23 +14,21 @@ interface StoredMsaData {
   timestamp: number
 }
 
-let dbPromise: ReturnType<typeof openDB> | undefined
-
-function getDB() {
-  dbPromise ??= openDB(DB_NAME, DB_VERSION, {
-    upgrade(db) {
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' })
-        store.createIndex('timestamp', 'timestamp', { unique: false })
-      }
-    },
-  }).catch((e: unknown) => {
-    dbPromise = undefined
-    throw e
-  })
-  return dbPromise
+interface MsaDataDB extends DBSchema {
+  [STORE_NAME]: {
+    key: string
+    value: StoredMsaData
+    indexes: { timestamp: number }
+  }
 }
 
+const getDB = createDbOpener<MsaDataDB>(DB_NAME, DB_VERSION, db => {
+  if (!db.objectStoreNames.contains(STORE_NAME)) {
+    const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' })
+    store.createIndex('timestamp', 'timestamp', { unique: false })
+  }
+})
+
 export function generateDataStoreId() {
   return `msa-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
 }
@@ -57,7 +57,7 @@ export async function storeMsaData(
 export async function retrieveMsaData(id: string) {
   try {
     const db = await getDB()
-    const result = (await db.get(STORE_NAME, id)) as StoredMsaData | undefined
+    const result = await db.get(STORE_NAME, id)
     if (result) {
       return {
         msa: result.msa,

package/src/MsaViewPanel/syncGenomeHoverToMsaColumn.test.ts

@@ -56,13 +56,15 @@ describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
     vi.clearAllMocks()
   })
 
-  test('genome hover at coord 1005 highlights MSA column 5', () => {
+  test('genome hover at coord 1005 highlights MSA column 4', () => {
     const { model, calls } = makeModel()
     const run = syncGenomeHoverToMsaColumn(model)
 
-    hoverGenome(1005) // 1005 - mafRegion.start(1000) = ungapped 5
+    // the hover coord is 1-based, so 1005 is the 0-based base 1004, i.e.
+    // ungapped offset 4 into a region starting at 1000
+    hoverGenome(1005)
     run()
-    expect(calls).toEqual([5])
+    expect(calls).toEqual([4])
   })
 
   test('moving the genome hover moves the highlighted column', () => {
@@ -73,7 +75,7 @@ describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
     run()
     hoverGenome(1007)
     run()
-    expect(calls).toEqual([2, 7])
+    expect(calls).toEqual([1, 6])
   })
 
   test('leaving the genome clears the column it set', () => {
@@ -84,7 +86,7 @@ describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
     run()
     clearGenomeHover()
     run()
-    expect(calls).toEqual([4, undefined])
+    expect(calls).toEqual([3, undefined])
   })
 
   test('a hover outside the maf region clears a previously-set column once', () => {
@@ -96,7 +98,7 @@ describe('syncGenomeHoverToMsaColumn (real genomeToMSA mapping)', () => {
     hoverGenome(5000) // outside [1000,1010) -> genomeToMSA returns undefined
     run()
     run()
-    expect(calls).toEqual([4, undefined])
+    expect(calls).toEqual([3, undefined])
   })
 
   test('never touches mouseCol when the genome never provides a column, so a direct MSA hover survives unrelated session hovers', () => {

package/src/utils/blastCache.ts

@@ -1,10 +1,11 @@
-import { openDB } from 'idb'
+import { createDbOpener } from './idb'
 
 import type {
   BlastDatabase,
   BlastProgram,
   MsaAlgorithm,
 } from '../LaunchMsaView/components/NCBIBlastQuery/consts'
+import type { DBSchema } from 'idb'
 
 const DB_NAME = 'jbrowse-msaview-blast-cache'
 const STORE_NAME = 'blast-results'
@@ -27,25 +28,26 @@ export interface CachedBlastResult {
   geneName?: string
 }
 
-let dbPromise: ReturnType<typeof openDB> | undefined
-
-function getDB() {
-  dbPromise ??= 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' })
-      }
-    },
-  }).catch((e: unknown) => {
-    dbPromise = undefined
-    throw e
-  })
-  return dbPromise
+interface BlastCacheDB extends DBSchema {
+  [STORE_NAME]: {
+    key: string
+    value: CachedBlastResult
+  }
 }
 
+const getDB = createDbOpener<BlastCacheDB>(
+  DB_NAME,
+  DB_VERSION,
+  (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: BlastDatabase,
@@ -125,8 +127,3 @@ 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/domainCache.ts

@@ -1,6 +1,7 @@
-import { openDB } from 'idb'
+import { createDbOpener } from './idb'
 
 import type { DomainMatch } from './ncbiDomains'
+import type { DBSchema } from 'idb'
 
 const DB_NAME = 'jbrowse-msaview-domain-cache'
 const STORE_NAME = 'domains'
@@ -11,29 +12,24 @@ interface CachedDomain {
   matches: DomainMatch[]
 }
 
-let dbPromise: ReturnType<typeof openDB> | undefined
-
-function getDB() {
-  dbPromise ??= openDB(DB_NAME, DB_VERSION, {
-    upgrade(db) {
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.createObjectStore(STORE_NAME, { keyPath: 'accession' })
-      }
-    },
-  }).catch((e: unknown) => {
-    dbPromise = undefined
-    throw e
-  })
-  return dbPromise
+interface DomainCacheDB extends DBSchema {
+  [STORE_NAME]: {
+    key: string
+    value: CachedDomain
+  }
 }
 
+const getDB = createDbOpener<DomainCacheDB>(DB_NAME, DB_VERSION, db => {
+  if (!db.objectStoreNames.contains(STORE_NAME)) {
+    db.createObjectStore(STORE_NAME, { keyPath: 'accession' })
+  }
+})
+
 export async function getCachedDomains(accessions: string[]) {
   const db = await getDB()
   const tx = db.transaction(STORE_NAME, 'readonly')
   const results = await Promise.all(
-    accessions.map(
-      accession => tx.store.get(accession) as Promise<CachedDomain | undefined>,
-    ),
+    accessions.map(accession => tx.store.get(accession)),
   )
   await tx.done
   return results

package/src/utils/idb.ts

@@ -0,0 +1,28 @@
+import { openDB } from 'idb'
+
+import type { DBSchema, IDBPDatabase, OpenDBCallbacks } from 'idb'
+
+/**
+ * Memoized `openDB` for a typed schema, shared by this plugin's caches.
+ *
+ * The connection promise is cached so callers share one connection, and dropped
+ * again if the open fails, so a later call retries instead of replaying the same
+ * rejection forever (IndexedDB is unavailable in some private-browsing modes).
+ *
+ * Passing a DBSchema is what keeps `get`/`getAll` from returning `any`: with an
+ * untyped database every cached record reaches the UI unchecked.
+ */
+export function createDbOpener<T extends DBSchema>(
+  name: string,
+  version: number,
+  upgrade: OpenDBCallbacks<T>['upgrade'],
+) {
+  let dbPromise: Promise<IDBPDatabase<T>> | undefined
+  return () => {
+    dbPromise ??= openDB<T>(name, version, { upgrade }).catch((e: unknown) => {
+      dbPromise = undefined
+      throw e
+    })
+    return dbPromise
+  }
+}

package/src/utils/ncbiOrthologs.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest'
+
+import { dedupeLabels, parseFasta } from './ncbiOrthologs'
+
+describe('dedupeLabels', () => {
+  test('sanitizes to single tokens', () => {
+    // labels are used identically as FASTA headers, Newick leaf names and GFF
+    // seq_ids, so anything that would need quoting in one of those is stripped
+    expect(dedupeLabels(['house mouse', 'Norway rat'])).toEqual([
+      'house_mouse',
+      'Norway_rat',
+    ])
+    expect(dedupeLabels(['Frog (X. tropicalis)'])).toEqual([
+      'Frog_X_tropicalis',
+    ])
+  })
+
+  test('suffixes collisions rather than overwriting a row', () => {
+    expect(dedupeLabels(['a b', 'a-b', 'a_b'])).toEqual([
+      'a_b',
+      'a_b_2',
+      'a_b_3',
+    ])
+  })
+
+  test('falls back for a name with no usable characters', () => {
+    expect(dedupeLabels(['...', '...'])).toEqual(['row', 'row_2'])
+  })
+})
+
+describe('parseFasta', () => {
+  test('keys by the first header token and joins wrapped lines', () => {
+    const map = parseFasta(
+      ['>NP_000537.3 cellular tumor antigen p53', 'MEEP', 'QSDP', ''].join(
+        '\n',
+      ),
+    )
+    expect(map.get('NP_000537.3')).toBe('MEEPQSDP')
+  })
+
+  test('reads every record of a multi-FASTA', () => {
+    const map = parseFasta(
+      ['>A one', 'MMM', '>B two', 'KKK', '>C three', 'LLL'].join('\n'),
+    )
+    expect([...map.keys()]).toEqual(['A', 'B', 'C'])
+    expect(map.get('C')).toBe('LLL')
+  })
+
+  test('returns nothing for a response that carried no records', () => {
+    // efetch answers an unknown accession with an error body, not a 4xx, so a
+    // caller that assumed "text back = sequences" would build empty rows
+    expect(parseFasta('Error: CEFetchPApplication::proxy_stream()').size).toBe(
+      0,
+    )
+  })
+})