react-msaview 6.4.2 → 7.0.0

package/src/impgRender.test.tsx

@@ -1,68 +0,0 @@
-// @vitest-environment jsdom
-//
-// End-to-end check of the impg (https://github.com/pangenome/impg) integration:
-// impg's scripts/faln2html.py drives the viewer exactly as below --
-//   MSAModelF().create({ type:'MsaView', data:{ msa } })
-//   model.setColorSchemeName('percent_identity_dynamic')
-//   model.setBgColor(true); model.setWidth(1300)
-// then renders <MSAView model/>. This exercises that path headlessly via the
-// public renderToSvg export. Polyfills mirror scripts/generateFigures.tsx.
-import { createJBrowseTheme } from '@jbrowse/core/ui/theme'
-import { beforeAll, expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-import { renderToSvg } from './renderToSvg.tsx'
-import { installSvgTestEnv } from './svgTestUtil.ts'
-
-beforeAll(() => {
-  installSvgTestEnv()
-})
-
-// representative `impg query -o fasta-aln` block: PanSN names with region
-// colons, dash gaps, mixed-case (soft-masked) bases
-const impgFastaAln = `>HG002#1#chr1:1000-1040
-ACGTACGT--ACGTNNNNacgtACGTACGTACGTACGT
->HG003#1#chr1:1000-1040
-ACGTAC-TGGACGTNNNNACGTAC--ACGTacgtACGT
->CHM13#0#chr1:1000-1040
-ACGTACGTGGACGTNNNNACGT----ACGTACGTACGT`
-
-test('renders an impg fasta-aln block with declarative impg config', async () => {
-  // everything except width is a declarative MST property, so it can be set in
-  // the create() snapshot -- no setColorSchemeName/setBgColor/setMSAFormat
-  // action calls needed. msaFormat:'fasta' forces the parser and skips the
-  // heuristic fasta-vs-a3m sniffing. width is volatile (tracks container size)
-  // so it remains an action.
-  const model = MSAModelF().create({
-    id: 'impg-test',
-    type: 'MsaView',
-    height: 400,
-    colorSchemeName: 'percent_identity_dynamic',
-    bgColor: true,
-    msaFormat: 'fasta',
-    data: { msa: impgFastaAln },
-  })
-  model.setWidth(1300)
-
-  // the declarative config took effect
-  expect(model.colorSchemeName).toBe('percent_identity_dynamic')
-  expect(model.bgColor).toBe(true)
-  expect(model.msaFormat).toBe('fasta')
-
-  // the alignment parsed and all 3 rows are present at equal width
-  expect(model.rowNames).toEqual([
-    'HG002#1#chr1:1000-1040',
-    'HG003#1#chr1:1000-1040',
-    'CHM13#0#chr1:1000-1040',
-  ])
-  expect(model.numColumns).toBe(38)
-
-  const svg = await renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'entire',
-    includeMinimap: false,
-    includeTracks: false,
-  })
-  expect(svg).toContain('<svg')
-  expect(svg).toContain('HG002#1#chr1:1000-1040')
-})

package/src/largeTree.test.ts

@@ -1,67 +0,0 @@
-// @vitest-environment jsdom
-import { expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-// jsdom has no 2d context, so measureTextCanvas falls back to an estimate. Only
-// the width matters here, so a stub keeps the test about tree size.
-HTMLCanvasElement.prototype.getContext = (() => ({
-  font: '12px sans-serif',
-  measureText: (t: string) => ({ width: t.length * 7 }),
-})) as unknown as typeof HTMLCanvasElement.prototype.getContext
-
-// The import form ships a "230k COVID-19 samples (tree only)" example, so a tree
-// this size is a supported input rather than a hypothetical. Every leaf gets a
-// measured label, and anything that then reduces over them per row has to do it
-// without passing one argument per row.
-function flatNewick(n: number) {
-  return `(${Array.from({ length: n }, (_, i) => `s${i}:0.1`).join(',')});`
-}
-
-test('a tree far past the argument limit still lays out', () => {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    data: { tree: flatNewick(200_000) },
-  })
-  model.setWidth(1000)
-
-  expect(model.numRows).toBe(200_000)
-  // 's199999' is the longest name, at 7 chars * 7px, scaled from the reference
-  // font size the labels are measured at down to the current one (13/16)
-  expect(model.labelsWidth).toBeCloseTo((49 * 13) / 16)
-  expect(model.treeWidth).toBeGreaterThan(0)
-})
-
-test('re-hovering the same tree node does not re-walk the tree', () => {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    data: { tree: flatNewick(200_000) },
-  })
-  model.setWidth(1000)
-
-  const leafId = model.leaves[1000]!.data.id
-  model.setHoveredTreeNode(leafId)
-  const first = model.hoveredTreeNode
-
-  // the tree's mousemove handler fires this on every event, so an unchanged id
-  // has to leave the state object alone: rebuilding it walks all 200k nodes and
-  // invalidates every overlay that reads hoveredRowIndices
-  model.setHoveredTreeNode(leafId)
-  expect(model.hoveredTreeNode).toBe(first)
-
-  model.setHoveredTreeNode(undefined)
-  expect(model.hoveredTreeNode).toBeUndefined()
-})
-
-test('a vertical zoom does not re-measure every label', () => {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    data: { tree: flatNewick(200_000) },
-  })
-  model.setWidth(1000)
-
-  const before = model.labelWidthMap
-  model.setRowHeight(24)
-  expect(model.labelWidthMap).toBe(before)
-  expect(model.labelsWidth).toBeCloseTo((49 * 18) / 16)
-})

package/src/launchInterProScan.ts

@@ -1,167 +0,0 @@
-import { getSession } from '@jbrowse/core/util'
-import { interProScanResponseToAnnotations } from 'msa-parsers'
-
-import { isAbortError, jsonfetch, textfetch, timeout } from './fetchUtils.ts'
-
-import type { MsaViewModel } from './model.ts'
-import type { InterProScanResponse } from 'msa-parsers'
-
-const base = 'https://www.ebi.ac.uk/Tools/services/rest'
-
-async function runInterProScan({
-  seq,
-  onProgress,
-  onJobId,
-  programs,
-  model,
-  signal,
-}: {
-  seq: string
-  programs: string[]
-  onProgress: (arg?: { msg: string; url?: string }) => void
-  onJobId?: (arg: string) => void
-  model: MsaViewModel
-  signal?: AbortSignal
-}) {
-  const jobId = await textfetch(`${base}/iprscan5/run`, {
-    method: 'POST',
-    body: new URLSearchParams({
-      email: 'colin.diesh@gmail.com',
-      sequence: seq,
-      programs: programs.join(','),
-    }),
-    signal,
-  })
-  onJobId?.(jobId)
-  await wait({
-    jobId,
-    onProgress,
-    signal,
-  })
-  await loadInterProScanResultsWithStatus({ jobId, model, onProgress, signal })
-}
-
-function loadInterProScanResults(jobId: string, signal?: AbortSignal) {
-  return jsonfetch<InterProScanResponse>(
-    `${base}/iprscan5/result/${jobId}/json`,
-    { signal },
-  )
-}
-
-async function wait({
-  onProgress,
-  jobId,
-  signal,
-}: {
-  jobId: string
-  onProgress: (arg?: { msg: string; url?: string }) => void
-  signal?: AbortSignal
-}) {
-  const url = `${base}/iprscan5/status/${jobId}`
-  // EBI jobs run for minutes; cap polling so an unexpected/stuck status can't
-  // spin forever (the abort signal is the normal early exit). ~10s per check.
-  const maxChecks = 360
-  try {
-    let finished = false
-    for (let check = 0; check < maxChecks && !finished; check++) {
-      for (let i = 0; i < 10; i++) {
-        await timeout(1000, signal)
-        onProgress({ msg: `Checking status ${10 - i}`, url })
-      }
-      // status endpoint returns a bare status token; match exactly rather than
-      // substring so an error page mentioning "FINISHED" can't be a false hit
-      const status = (await textfetch(url, { signal })).trim()
-      if (status === 'FINISHED') {
-        finished = true
-      } else if (
-        status === 'FAILURE' ||
-        status === 'ERROR' ||
-        status === 'NOT_FOUND'
-      ) {
-        throw new Error(
-          `InterProScan job ${jobId} ended with status: ${status}`,
-        )
-      }
-    }
-    if (!finished) {
-      throw new Error(
-        `InterProScan job ${jobId} did not finish after ${maxChecks} status checks`,
-      )
-    }
-  } finally {
-    onProgress()
-  }
-}
-
-export async function launchInterProScan({
-  algorithm,
-  seq,
-  programs,
-  onJobId,
-  onProgress,
-  model,
-  signal,
-}: {
-  algorithm: string
-  seq: string
-  programs: string[]
-  onProgress: (arg?: { msg: string; url?: string }) => void
-  onJobId?: (arg: string) => void
-  model: MsaViewModel
-  signal?: AbortSignal
-}) {
-  try {
-    onProgress({ msg: `Launching ${algorithm} MSA` })
-    if (algorithm === 'interproscan') {
-      await runInterProScan({
-        seq,
-        onJobId,
-        onProgress,
-        programs,
-        model,
-        signal,
-      })
-    } else {
-      throw new Error('unknown algorithm')
-    }
-  } catch (e) {
-    if (isAbortError(e)) {
-      getSession(model).notify('Cancelled InterProScan query', 'info')
-    } else {
-      throw e
-    }
-  } finally {
-    onProgress()
-  }
-}
-
-async function loadInterProScanResultsWithStatus({
-  jobId,
-  model,
-  onProgress,
-  signal,
-}: {
-  jobId: string
-  model: MsaViewModel
-  onProgress: (arg?: { msg: string; url?: string }) => void
-  signal?: AbortSignal
-}) {
-  try {
-    onProgress({
-      msg: `Downloading results of ${jobId} (for larger sequences this can be slow, click status to download and upload in the manual tab)`,
-      url: `https://www.ebi.ac.uk/Tools/services/rest/iprscan5/result/${jobId}/json`,
-    })
-    const ret = await loadInterProScanResults(jobId, signal)
-    model.setAnnotations(interProScanResponseToAnnotations(ret))
-    getSession(model).notify(`Loaded interproscan ${jobId} results`, 'success')
-  } catch (e) {
-    if (isAbortError(e)) {
-      getSession(model).notify('Cancelled InterProScan query', 'info')
-    } else {
-      console.error(e)
-      getSession(model).notifyError(`${e}`, e)
-    }
-  } finally {
-    onProgress()
-  }
-}

package/src/loadErrorDisplay.test.tsx

@@ -1,102 +0,0 @@
-// @vitest-environment jsdom
-//
-// What a failed load LOOKS like, which is a different question from what the
-// model recorded. modelFilehandleLoaders.test.ts already pins the model half --
-// a rejected fetch sets `error` and clears `loadingMSA`, under the name "a
-// failed fetch surfaces as an error" -- and it passed throughout the whole time
-// a failed url showed the reader a spinner and nothing else.
-//
-// The error display was never missing. ImportForm renders `model.error`, and
-// the reader could not get to it: a non-abort failure KEEPS its filehandle
-// (only an abort clears it), so `hasPendingFilehandle` stayed true and
-// Loading.tsx took its spinner branch ahead of the import form, permanently.
-// Found on AlphaFold's `files/msa/` prefix answering 403 to every key in August
-// 2026 -- the view opened, said "Downloading file" with a Cancel button, and
-// was still saying it at 105s.
-import React, { act } from 'react'
-
-import { createRoot } from 'react-dom/client'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-
-import MSAView from './components/Loading.tsx'
-import MSAModelF from './model.ts'
-
-import type { MsaViewModel } from './model.ts'
-import type { Root } from 'react-dom/client'
-
-Reflect.set(globalThis, 'IS_REACT_ACT_ENVIRONMENT', true)
-
-let container: HTMLDivElement
-let root: Root
-let model: MsaViewModel
-
-function uri(u: string) {
-  return { locationType: 'UriLocation' as const, uri: u }
-}
-
-function render() {
-  act(() => {
-    root.render(<MSAView model={model} />)
-  })
-}
-
-beforeEach(() => {
-  container = document.createElement('div')
-  document.body.append(container)
-  root = createRoot(container)
-  model = MSAModelF().create({ type: 'MsaView' })
-  model.setWidth(800)
-})
-
-afterEach(() => {
-  act(() => {
-    root.unmount()
-  })
-  container.remove()
-})
-
-test('a load that fails shows the error rather than a spinner forever', () => {
-  // the state the loader leaves behind on a 403: the filehandle it could not
-  // read is still set, nothing parsed, and the error recorded
-  model.setMSAFilehandle(uri('https://example.com/blocked.a3m'))
-  model.setLoadingMSA(false)
-  model.setError(new Error('HTTP 403 fetching blocked.a3m'))
-  render()
-
-  expect(container.textContent).toContain('403')
-  expect(container.textContent).not.toContain('Loading')
-})
-
-test('a load still in flight is a spinner, not an error', () => {
-  model.setMSAFilehandle(uri('https://example.com/slow.a3m'))
-  render()
-
-  expect(model.loadingMSA).toBe(true)
-  expect(container.textContent).not.toContain('Return to import form')
-})
-
-// A guard rather than a pin: this one passes without the fix too, because with
-// no filehandle left set the view reaches the ImportForm and that already shows
-// the error. It is here so the new branch cannot quietly swallow the case.
-//
-// It also records the surprise underneath: `dataInitialized` is itself
-// `(msa || tree) && !error`, so ANY error hides a loaded alignment, including a
-// tree or gff that 404s beside a good one -- setError is shared by every
-// filehandle loader. Whether a failed OPTIONAL file should blank a good
-// alignment is a real question and a wider one, since `dataInitialized` is read
-// in several places; narrowing it is a design change rather than this fix.
-test('an error over loaded data says so instead of a bare import form', () => {
-  const loaded = MSAModelF().create({
-    type: 'MsaView',
-    msaFormat: 'fasta',
-    height: 200,
-    data: { msa: '>seq1\nACDE\n>seq2\nACDF' },
-  })
-  loaded.setWidth(800)
-  loaded.setError(new Error('domains.gff 404'))
-  act(() => {
-    root.render(<MSAView model={loaded} />)
-  })
-
-  expect(container.textContent).toContain('domains.gff 404')
-})

package/src/modelFilehandleLoaders.test.ts

@@ -1,137 +0,0 @@
-// The reactive filehandle loaders in afterCreate: each fetches when its
-// filehandle changes, and each guards against a stale response, since a user can
-// pick a second file while the first is still downloading.
-import { beforeEach, expect, test, vi } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-import type * as FetchUtils from './fetchUtils.ts'
-
-// uri -> settle functions for the fetch that autorun kicked off
-const inFlight = new Map<
-  string,
-  { resolve: (text: string) => void; reject: (e: unknown) => void }
->()
-
-vi.mock('@jbrowse/core/util/io', () => ({
-  openLocation: (loc: { uri: string }) => loc,
-}))
-
-vi.mock('./fetchUtils.ts', async importOriginal => ({
-  ...(await importOriginal<typeof FetchUtils>()),
-  fetchTextWithProgress: (loc: { uri: string }) =>
-    new Promise<string>((resolve, reject) => {
-      inFlight.set(loc.uri, { resolve, reject })
-    }),
-}))
-
-function uri(u: string) {
-  return { locationType: 'UriLocation' as const, uri: u }
-}
-
-function fasta(seq: string) {
-  return `>seq1\n${seq}`
-}
-
-// let the awaited fetch and the actions that follow it run
-function flush() {
-  return new Promise(resolve => setTimeout(resolve, 0))
-}
-
-function makeModel() {
-  const model = MSAModelF().create({ type: 'MsaView' })
-  model.setWidth(800)
-  return model
-}
-
-beforeEach(() => {
-  inFlight.clear()
-})
-
-test('an msa filehandle loads into the model and clears its loading flag', async () => {
-  const model = makeModel()
-  model.setMSAFilehandle(uri('aln.fa'))
-  expect(model.loadingMSA).toBe(true)
-
-  inFlight.get('aln.fa')!.resolve(fasta('ACDE'))
-  await flush()
-
-  expect(model.data.msa).toBe(fasta('ACDE'))
-  expect(model.loadingMSA).toBe(false)
-})
-
-test('a slower earlier fetch never clobbers a newer one', async () => {
-  const model = makeModel()
-  model.setMSAFilehandle(uri('first.fa'))
-  model.setMSAFilehandle(uri('second.fa'))
-
-  // the newer fetch finishes first, then the abandoned one comes back
-  inFlight.get('second.fa')!.resolve(fasta('SECOND'))
-  await flush()
-  inFlight.get('first.fa')!.resolve(fasta('FIRST'))
-  await flush()
-
-  expect(model.data.msa).toBe(fasta('SECOND'))
-  expect(model.loadingMSA).toBe(false)
-})
-
-test('a stale failure does not raise an error over live data', async () => {
-  const model = makeModel()
-  model.setMSAFilehandle(uri('first.fa'))
-  model.setMSAFilehandle(uri('second.fa'))
-
-  inFlight.get('second.fa')!.resolve(fasta('SECOND'))
-  await flush()
-  inFlight.get('first.fa')!.reject(new Error('too slow'))
-  await flush()
-
-  expect(model.error).toBeUndefined()
-  expect(model.data.msa).toBe(fasta('SECOND'))
-})
-
-test('cancelling drops the filehandle so the view returns to the import form', async () => {
-  const model = makeModel()
-  model.setMSAFilehandle(uri('aln.fa'))
-
-  inFlight.get('aln.fa')!.reject(new DOMException('Aborted', 'AbortError'))
-  await flush()
-
-  expect(model.msaFilehandle).toBeUndefined()
-  expect(model.error).toBeUndefined()
-  expect(model.loadingMSA).toBe(false)
-})
-
-test('a failed fetch surfaces as an error', async () => {
-  const model = makeModel()
-  model.setMSAFilehandle(uri('aln.fa'))
-
-  inFlight.get('aln.fa')!.reject(new Error('404'))
-  await flush()
-
-  expect(model.error).toBeInstanceOf(Error)
-  expect(model.loadingMSA).toBe(false)
-})
-
-test('tree, treeMetadata and gff filehandles each load into their own field', async () => {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    treeFilehandle: uri('tree.nh'),
-    treeMetadataFilehandle: uri('meta.json'),
-    gffFilehandle: uri('domains.gff'),
-  })
-  model.setWidth(800)
-
-  inFlight.get('tree.nh')!.resolve('(a,b);')
-  inFlight.get('meta.json')!.resolve('{"a":{"genome":"human"}}')
-  inFlight
-    .get('domains.gff')!
-    .resolve(
-      '##gff-version 3\na\tPfam\tprotein_match\t1\t2\t.\t.\t.\tName=PF00069',
-    )
-  await flush()
-
-  expect(model.data.tree).toBe('(a,b);')
-  expect(model.treeMetadata.a?.genome).toBe('human')
-  expect(model.actuallyShowDomains).toBe(true)
-  expect(model.loadingTree).toBe(false)
-})

package/src/modelReset.test.ts

@@ -1,120 +0,0 @@
-// reset() returns the view to the import form, and the next file loads into
-// the same model instance. It applies a default snapshot filtered to
-// preservedOnReset, so anything file-derived that survived would be a hole in
-// that list — the last test enumerates the snapshot keys to keep the list and
-// the model's properties from drifting apart as properties are added. The
-// stakes: node ids are path-derived (node-0-0-1), so a stale collapsed or
-// showOnly id names a real node in the next tree and folds it.
-import { getSnapshot } from '@jbrowse/mobx-state-tree'
-import { describe, expect, test } from 'vitest'
-
-import MSAModelF, { preservedOnReset } from './model.ts'
-
-const firstFile = {
-  msa: '>a\nACGT\n>b\nACGT\n>c\nACGT\n>d\nACGT',
-  tree: '((a,b),(c,d));',
-}
-const secondFile = {
-  msa: '>e\nTTTT\n>f\nTTTT\n>g\nTTTT\n>h\nTTTT',
-  tree: '((e,f),(g,h));',
-}
-
-function makeModel() {
-  const model = MSAModelF().create({ type: 'MsaView', data: firstFile })
-  model.setWidth(800)
-  return model
-}
-
-function internalNodeId(model: ReturnType<typeof makeModel>) {
-  return model.leaves[0]!.parent!.data.id
-}
-
-describe('reset', () => {
-  test('a collapsed clade does not fold the next loaded tree', () => {
-    const model = makeModel()
-    model.toggleCollapsed(internalNodeId(model))
-    expect(model.leaves.length).toBe(3)
-
-    model.reset()
-    model.setData(secondFile)
-    expect(model.collapsed.length).toBe(0)
-    expect(model.leaves.map(l => l.data.name).toSorted()).toEqual([
-      'e',
-      'f',
-      'g',
-      'h',
-    ])
-  })
-
-  test('showOnly does not restrict the next loaded tree', () => {
-    const model = makeModel()
-    model.setShowOnly(internalNodeId(model))
-    expect(model.leaves.length).toBe(2)
-
-    model.reset()
-    model.setData(secondFile)
-    expect(model.showOnly).toBe(undefined)
-    expect(model.leaves.length).toBe(4)
-  })
-
-  test('clears file-derived volatiles', () => {
-    const model = makeModel()
-    model.setMousePos(2, 1)
-    model.setMouseClickPos(3, 0)
-    model.setHighlightedColumns([1, 2])
-    model.setHoveredTreeNode(internalNodeId(model))
-
-    model.reset()
-    expect(model.mouseCol).toBe(undefined)
-    expect(model.mouseClickCol).toBe(undefined)
-    expect(model.highlightedColumns).toBe(undefined)
-    expect(model.hoveredTreeNode).toBe(undefined)
-    expect(model.error).toBe(undefined)
-    expect(model.annotations).toEqual([])
-  })
-
-  test('display preferences survive', () => {
-    const model = makeModel()
-    model.setColorSchemeName('clustalx')
-    model.setDrawNodeBubbles(false)
-    model.toggleTrack('conservation')
-
-    model.reset()
-    expect(model.colorSchemeName).toBe('clustalx')
-    expect(model.drawNodeBubbles).toBe(false)
-    expect(model.turnedOffTracks.get('conservation')).toBe(true)
-  })
-
-  test('every property off preservedOnReset matches a fresh model', () => {
-    const model = makeModel()
-    model.toggleCollapsed(internalNodeId(model))
-    model.setShowOnly(internalNodeId(model))
-    model.drawRelativeTo('a')
-    model.setFilter('PF00001', true)
-    model.setScrollX(-100)
-    model.setScrollY(-50)
-    model.zoomIn()
-    model.setCurrentAlignment(1)
-    model.setMSAFilehandle({
-      uri: 'http://x/msa.fa',
-      locationType: 'UriLocation',
-    })
-    model.setTreeFilehandle({
-      uri: 'http://x/t.nh',
-      locationType: 'UriLocation',
-    })
-    model.setTreeMetadataFilehandle({
-      uri: 'http://x/m.json',
-      locationType: 'UriLocation',
-    })
-    model.setMSAFormat('fasta')
-
-    model.reset()
-    const fresh = MSAModelF().create({ type: 'MsaView' })
-    const strip = (snap: object) =>
-      Object.fromEntries(
-        Object.entries(snap).filter(([key]) => !preservedOnReset.has(key)),
-      )
-    expect(strip(getSnapshot(model))).toEqual(strip(getSnapshot(fresh)))
-  })
-})