jbrowse-plugin-msaview 3.4.0 → 3.4.1

package/src/utils/ebiJobDispatcher.ts

@@ -1,4 +1,4 @@
-import { textfetch } from './fetch'
+import { isAbortError, textfetch } from './fetch'
 import { pollLoop } from './poll'
 import { readLocalStorage } from './useLocalStorage'
 
@@ -35,13 +35,16 @@ const FAILED_STATUSES = new Set(['ERROR', 'FAILURE', 'NOT_FOUND'])
 export async function submitEbiJob({
   tool,
   params,
+  signal,
 }: {
   tool: string
   params: Record<string, string>
+  signal?: AbortSignal
 }) {
   const jobId = await textfetch(`${EBI_BASE}/${tool}/run`, {
     method: 'POST',
     body: new URLSearchParams({ email: getEbiEmail(), ...params }),
+    signal,
   })
   return jobId.trim()
 }
@@ -64,21 +67,31 @@ export async function waitForEbiJob({
   jobId,
   intervalSeconds = 10,
   onCountdown,
+  signal,
 }: {
   tool: string
   jobId: string
   intervalSeconds?: number
   onCountdown: (secondsRemaining: number) => void
+  signal?: AbortSignal
 }) {
   let consecutiveFailures = 0
   await pollLoop({
     intervalSeconds,
     onCountdown,
+    signal,
     check: async () => {
       let status: string
       try {
-        status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim()
+        status = (
+          await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`, { signal })
+        ).trim()
       } catch (e) {
+        // a cancelled request is the caller giving up, not EBI being
+        // unreachable, so it must end the poll rather than be retried
+        if (isAbortError(e)) {
+          throw e
+        }
         consecutiveFailures += 1
         if (consecutiveFailures >= MAX_CONSECUTIVE_STATUS_FAILURES) {
           throw new Error(
@@ -111,10 +124,12 @@ export async function fetchEbiResult({
   tool,
   jobId,
   type,
+  signal,
 }: {
   tool: string
   jobId: string
   type: string
+  signal?: AbortSignal
 }) {
-  return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`)
+  return textfetch(`${EBI_BASE}/${tool}/result/${jobId}/${type}`, { signal })
 }

package/src/utils/fetch.ts

@@ -45,6 +45,33 @@ export async function jsonfetch<T>(url: string, args?: RequestInit) {
   return response.json() as Promise<T>
 }
 
-export function timeout(time: number) {
-  return new Promise(res => setTimeout(res, time))
+export function timeout(time: number, signal?: AbortSignal) {
+  return new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException('Aborted', 'AbortError'))
+      return
+    }
+    // the listener is removed on the natural path too: one signal serves every
+    // tick of a poll, and a 10-minute job is ~600 sleeps -- leaving each
+    // listener behind accumulates them all on that one signal
+    const onAbort = () => {
+      clearTimeout(id)
+      reject(new DOMException('Aborted', 'AbortError'))
+    }
+    const id = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort)
+      resolve()
+    }, time)
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+/**
+ * A cancelled launch has to be told apart from a failed one: it must not render
+ * the "failed" panel, and it must not touch a model that may already be gone.
+ * `fetch` and the sleep above both reject with a DOMException named AbortError,
+ * which subclasses Error.
+ */
+export function isAbortError(e: unknown) {
+  return e instanceof Error && e.name === 'AbortError'
 }

package/src/utils/msa.ts

@@ -43,9 +43,11 @@ const algorithms: Record<
 export async function launchTree({
   alignment,
   onProgress,
+  signal,
 }: {
   alignment: string
   onProgress: (arg: string) => void
+  signal?: AbortSignal
 }) {
   const tool = 'simple_phylogeny'
   onProgress('Building tree...')
@@ -58,25 +60,29 @@ export async function launchTree({
       clustering: 'Neighbour-joining',
       kimura: 'true',
     },
+    signal,
   })
   await waitForEbiJob({
     tool,
     jobId,
+    signal,
     onCountdown: s => {
       onProgress(`Re-checking tree status in... ${s}`)
     },
   })
-  return fetchEbiResult({ tool, jobId, type: 'tree' })
+  return fetchEbiResult({ tool, jobId, type: 'tree', signal })
 }
 
 export async function launchMSA({
   algorithm,
   sequence,
   onProgress,
+  signal,
 }: {
   algorithm: MsaAlgorithm
   sequence: string
   onProgress: (arg: string) => void
+  signal?: AbortSignal
 }) {
   const config = algorithms[algorithm]
 
@@ -85,18 +91,20 @@ export async function launchMSA({
   const jobId = await submitEbiJob({
     tool: algorithm,
     params: { ...config.params, sequence },
+    signal,
   })
   await waitForEbiJob({
     tool: algorithm,
     jobId,
+    signal,
     onCountdown: s => {
       onProgress(`Re-checking MSA status in... ${s}`)
     },
   })
   // one finished job, two result files, neither derived from the other
   const [msa, tree] = await Promise.all([
-    fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult }),
-    fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult }),
+    fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult, signal }),
+    fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult, signal }),
   ])
   return { msa, tree }
 }

package/src/utils/ncbiDomains.ts

@@ -97,7 +97,7 @@ function parseFeature(featureXml: string): DomainMatch | undefined {
  * domain and site annotations, keyed by both the versioned and primary
  * accession so callers can look up by whichever NCBI returned.
  */
-export function parseCddDomains(xml: string) {
+export function parseCddDomains(xml: string): Map<string, DomainMatch[]> {
   const byAccession = new Map<string, DomainMatch[]>()
   const seqRe = /<GBSeq>([\s\S]*?)<\/GBSeq>/g
   let seqMatch
@@ -132,7 +132,9 @@ export function parseCddDomains(xml: string) {
  * efetch returns them with no job submission or polling. Results are cached in
  * IndexedDB so reopening a view doesn't refetch.
  */
-export async function fetchProteinDomains(accessions: string[]) {
+export async function fetchProteinDomains(
+  accessions: string[],
+): Promise<Map<string, DomainMatch[]>> {
   const unique = [...new Set(accessions)].filter(Boolean)
   const byAccession = new Map<string, DomainMatch[]>()
 

package/src/utils/ncbiOrthologs.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test, vi } from 'vitest'
 
 import {
+  cleanGeneCandidate,
   dedupeLabels,
   fetchOrthologGenes,
   fetchRepresentativeProteins,
@@ -31,6 +32,30 @@ describe('dedupeLabels', () => {
   test('falls back for a name with no usable characters', () => {
     expect(dedupeLabels(['...', '...'])).toEqual(['row', 'row_2'])
   })
+
+  test('climbs past a suffix a literal name already took', () => {
+    // a label pairs a tree leaf to its alignment row, so handing the same one
+    // to two rows merges two species into one silently. The third label is ugly
+    // and unique, which is the trade
+    expect(dedupeLabels(['human', 'human', 'human_2'])).toEqual([
+      'human',
+      'human_2',
+      'human_2_2',
+    ])
+    expect(dedupeLabels(['human_2', 'human', 'human'])).toEqual([
+      'human_2',
+      'human',
+      'human_3',
+    ])
+  })
+})
+
+describe('cleanGeneCandidate', () => {
+  test('strips what a GFF feature carries that a gene lookup does not want', () => {
+    expect(cleanGeneCandidate(' gene:TP53 ')).toBe('TP53')
+    expect(cleanGeneCandidate('NM_000546.6')).toBe('NM_000546')
+    expect(cleanGeneCandidate('TP53')).toBe('TP53')
+  })
 })
 
 describe('parseFasta', () => {

package/src/utils/ncbiOrthologs.ts

@@ -70,6 +70,19 @@ function ncbiUrl(url: string) {
   return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`
 }
 
+/**
+ * A candidate gene reference as the ortholog services know it: a GFF ID prefix
+ * (gene:TP53) and a version suffix (NM_000546.6) stripped off. Shared with
+ * pantherOrthologs, which asks PANTHER the same question with the same
+ * candidates.
+ */
+export function cleanGeneCandidate(raw: string) {
+  return raw
+    .trim()
+    .replace(/^\w+:/, '')
+    .replace(/\.\d+$/, '')
+}
+
 /**
  * A free-text gene reference -> NCBI gene id. A bare number is taken as the id
  * itself; anything else is searched as a gene name within the query taxon.
@@ -89,8 +102,7 @@ export async function resolveGeneId(
     if (/^\d+$/.test(query)) {
       return { geneId: query, matched: query }
     }
-    // strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53)
-    const cleaned = query.replace(/^\w+:/, '').replace(/\.\d+$/, '')
+    const cleaned = cleanGeneCandidate(query)
     const term = `${cleaned}[Gene Name] AND ${taxId}[taxid]`
     const json = await jsonfetch<{
       esearchresult?: { idlist?: string[] }
@@ -261,15 +273,23 @@ function sanitize(name: string) {
  * Sanitized, unique single-token labels used identically in the FASTA headers,
  * the tree leaf names and the domain GFF seq_ids — that identity is how the
  * viewer pairs a tree leaf to its alignment row to its domain track. Collisions
- * get a numeric suffix rather than silently overwriting a row.
+ * get a numeric suffix rather than silently overwriting a row, and the suffix
+ * climbs past labels already emitted: a species genuinely named `human_2` would
+ * otherwise take the label the second `human` is about to get, merging two rows
+ * into one.
  */
 export function dedupeLabels(names: string[]) {
-  const seen = new Map<string, number>()
+  const used = new Set<string>()
   return names.map(name => {
     const base = sanitize(name) || 'row'
-    const n = seen.get(base) ?? 0
-    seen.set(base, n + 1)
-    return n === 0 ? base : `${base}_${n + 1}`
+    let label = base
+    let n = 1
+    while (used.has(label)) {
+      n += 1
+      label = `${base}_${n}`
+    }
+    used.add(label)
+    return label
   })
 }
 

package/src/utils/pantherOrthologs.ts

@@ -17,7 +17,11 @@
 // to a RefSeq accession.
 
 import { jsonfetch } from './fetch'
-import { dedupeLabels, defaultMaxSpecies } from './ncbiOrthologs'
+import {
+  cleanGeneCandidate,
+  dedupeLabels,
+  defaultMaxSpecies,
+} from './ncbiOrthologs'
 import { fetchTaxonomyInfo } from './taxonomyNames'
 
 import type { OrthologRow } from './ncbiOrthologs'
@@ -212,15 +216,6 @@ async function fetchSequences(accessions: string[]) {
   return map
 }
 
-// strip a version suffix (NM_000546.6) and any GFF ID prefix (gene:TP53), as
-// resolveGeneId does for NCBI
-function cleanCandidate(raw: string) {
-  return raw
-    .trim()
-    .replace(/^\w+:/, '')
-    .replace(/\.\d+$/, '')
-}
-
 /**
  * One `matchortho` per candidate until PANTHER maps one. A JBrowse feature
  * carries whatever its GFF/BigBed had — `id()`, `name`, `gene_name` — and only
@@ -234,7 +229,7 @@ async function matchOrthologs(
 ) {
   let matched: string | undefined
   for (const raw of candidates) {
-    const query = cleanCandidate(raw)
+    const query = cleanGeneCandidate(raw)
     if (!query) {
       continue
     }

package/src/utils/phmmer.ts

@@ -137,11 +137,13 @@ export async function queryPhmmer({
   database,
   onProgress,
   onRid,
+  signal,
 }: {
   query: string
   database: PhmmerDatabase
   onProgress: (arg: string) => void
   onRid: (arg: string) => void
+  signal?: AbortSignal
 }) {
   onProgress('Submitting to EBI phmmer...')
   const jobId = await submitEbiJob({
@@ -152,19 +154,21 @@ export async function queryPhmmer({
       // the alignment is the whole point of using phmmer here
       alignView: 'true',
     },
+    signal,
   })
   onRid(jobId)
 
   await waitForEbiJob({
     tool: TOOL,
     jobId,
+    signal,
     onCountdown: s => {
       onProgress(`Re-checking phmmer status in... ${s}`)
     },
   })
 
   const alignment = parsePhmmerAlignment({
-    stockholm: await fetchEbiResult({ tool: TOOL, jobId, type: 'sto' }),
+    stockholm: await fetchEbiResult({ tool: TOOL, jobId, type: 'sto', signal }),
     query,
   })
   if (alignment.rows.length === 0) {

package/src/utils/poll.ts

@@ -5,24 +5,31 @@ import { timeout } from './fetch'
  * false when still pending, and throws on failure. Between checks it counts down
  * `intervalSeconds`, calling `onCountdown` each second so the UI can show
  * progress.
+ *
+ * `signal` ends the loop with an AbortError: the countdown rejects on the tick
+ * it is aborted rather than at the end of the interval, so a cancelled launch
+ * stops within a second instead of running for the job's lifetime.
  */
 export async function pollLoop({
   check,
   intervalSeconds,
   onCountdown,
+  signal,
 }: {
   check: () => Promise<boolean>
   intervalSeconds: number
   onCountdown: (secondsRemaining: number) => void
+  signal?: AbortSignal
 }) {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   while (true) {
+    signal?.throwIfAborted()
     if (await check()) {
       return
     }
     for (let i = intervalSeconds; i > 0; i--) {
       onCountdown(i)
-      await timeout(1000)
+      await timeout(1000, signal)
     }
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '3.4.0'
+export const version = '3.4.1'