react-msaview 6.5.0 → 8.0.0

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)))
-  })
-})

package/src/neighborJoining.test.ts

@@ -1,164 +0,0 @@
-import { parseNewick } from 'msa-parsers'
-import { describe, expect, test } from 'vitest'
-
-import { calculateNeighborJoiningTree } from './neighborJoining.ts'
-
-import type { NewickNode } from '@gmod/newick'
-
-describe('calculateNeighborJoiningTree', () => {
-  test('generates valid Newick tree for 2 sequences', () => {
-    const rows: [string, string][] = [
-      ['seq1', 'MKAA'],
-      ['seq2', 'MKAA'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    expect(tree).toContain('seq1')
-    expect(tree).toContain('seq2')
-  })
-
-  test('generates valid Newick tree for 3 sequences', () => {
-    const rows: [string, string][] = [
-      ['human', 'MKAAYLSMFG'],
-      ['mouse', 'MKAAYLSMFG'],
-      ['chicken', 'MKAAFLSMFG'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    expect(tree).toContain('human')
-    expect(tree).toContain('mouse')
-    expect(tree).toContain('chicken')
-    expect(tree).toContain('(')
-    expect(tree).toContain(')')
-  })
-
-  test('generates valid Newick tree for 4 sequences', () => {
-    const rows: [string, string][] = [
-      ['A', 'MKAAYLSMFGKED'],
-      ['B', 'MKAAYLSMFGKED'],
-      ['C', 'MKAAFLSMFGKEE'],
-      ['D', 'MKAAFLSMFGKEE'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    expect(tree).toContain('A')
-    expect(tree).toContain('B')
-    expect(tree).toContain('C')
-    expect(tree).toContain('D')
-  })
-
-  test('includes branch lengths in tree', () => {
-    const rows: [string, string][] = [
-      ['seq1', 'MKAAYLSMFG'],
-      ['seq2', 'MKAAFLSMFG'],
-      ['seq3', 'MKBBFLSMFG'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    // Branch lengths are formatted as :0.123456
-    expect(tree).toMatch(/:\d+\.\d+/)
-  })
-
-  test('throws error for less than 2 sequences', () => {
-    const rows: [string, string][] = [['seq1', 'MKAA']]
-    expect(() => calculateNeighborJoiningTree(rows)).toThrow(
-      'Need at least 2 sequences',
-    )
-  })
-
-  test('handles sequences with gaps', () => {
-    const rows: [string, string][] = [
-      ['seq1', 'MK-AYLSMFG'],
-      ['seq2', 'MKAAYLSMFG'],
-      ['seq3', 'MKA-YLSMFG'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    expect(tree).toContain('seq1')
-    expect(tree).toContain('seq2')
-    expect(tree).toContain('seq3')
-  })
-
-  test('treats a dot gap the same as a dash gap', () => {
-    // stockholm and a3m pad with '.', so the two spellings have to score alike
-    const withDashes: [string, string][] = [
-      ['seq1', 'MK-AYLSMFG'],
-      ['seq2', 'MKAAYLSMFG'],
-      ['seq3', 'MKA-YLSMFG'],
-    ]
-    const withDots = withDashes.map(
-      ([name, seq]) => [name, seq.replaceAll('-', '.')] as [string, string],
-    )
-    expect(calculateNeighborJoiningTree(withDots)).toBe(
-      calculateNeighborJoiningTree(withDashes),
-    )
-  })
-
-  test('names with special characters round-trip through Newick parsing', () => {
-    const rows: [string, string][] = [
-      ['EU105457.1|chr09:67680268..67675529_LTR/Copia', 'MKAA'],
-      ['seq(2)', 'MKAA'],
-    ]
-    const newick = calculateNeighborJoiningTree(rows)
-    const tree = parseNewick(newick)
-
-    function getLeafNames(node: NewickNode): (string | undefined)[] {
-      return node.children?.length
-        ? node.children.flatMap(c => getLeafNames(c))
-        : [node.name]
-    }
-    const names = getLeafNames(tree)
-    expect(names).toContain('EU105457.1|chr09:67680268..67675529_LTR/Copia')
-    expect(names).toContain('seq(2)')
-  })
-
-  test('identical sequences have zero distance', () => {
-    const rows: [string, string][] = [
-      ['seq1', 'MKAAYLSMFG'],
-      ['seq2', 'MKAAYLSMFG'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    // Identical sequences should have equal branch lengths
-    const match = tree.match(/:(\d+\.\d+)/g)
-    expect(match).not.toBeNull()
-    if (match) {
-      const lengths = match.map(m => parseFloat(m.slice(1)))
-      // Branch lengths should be small or zero for identical sequences
-      for (const len of lengths) {
-        expect(len).toBeGreaterThanOrEqual(0)
-      }
-    }
-  })
-
-  test('more divergent sequences have larger distances', () => {
-    const rows: [string, string][] = [
-      ['similar1', 'MKAAYLSMFGKED'],
-      ['similar2', 'MKAAYLSMFGKED'],
-      ['different', 'WWWWWWWWWWWWW'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    // The tree should be valid even with very different sequences
-    expect(tree).toContain('similar1')
-    expect(tree).toContain('similar2')
-    expect(tree).toContain('different')
-  })
-
-  test('handles ragged rows, treating a short row as gapped past its end', () => {
-    const rows: [string, string][] = [
-      ['full', 'MKAAYLSMFGKED'],
-      ['short', 'MKAAYL'],
-      ['other', 'WWWWWWWWWWWWW'],
-    ]
-    const tree = calculateNeighborJoiningTree(rows)
-
-    expect(tree).toMatch(/;$/)
-    expect(tree).toContain('short')
-  })
-})

package/src/parseAsn1.test.ts

@@ -1,36 +0,0 @@
-import { readFileSync } from 'node:fs'
-
-import { expect, test } from 'vitest'
-
-import { flatToTree } from './flatToTree.ts'
-import MSAModelF from './model.ts'
-import { parseAsn1 } from './parseAsn1.ts'
-
-const r = readFileSync(
-  new URL('../test/data/tree.asn', import.meta.url),
-  'utf8',
-)
-
-test('real data file', () => {
-  expect(parseAsn1(r)).toMatchSnapshot()
-})
-
-test('throws a clear error on input missing required sections', () => {
-  expect(() => parseAsn1('BioTreeContainer ::= { something {} }')).toThrow(
-    /missing/,
-  )
-})
-
-test('the tree keeps the labels and branch lengths the file carries', () => {
-  // the parsed features have to survive into the tree the viewer draws, or a
-  // BLAST tree renders as a lengthless list of node ids
-  const model = MSAModelF().create({ type: 'MsaView', data: { tree: r } })
-  model.setWidth(1000)
-
-  expect(model.numRows).toBe(101)
-  expect(model.rowNames[0]).toBe(
-    'sodium/glucose cotransporter 4 [Gouania willdenowi]',
-  )
-  expect(model.allBranchesLength0).toBe(false)
-  expect(flatToTree(parseAsn1(r)).length).toBeUndefined()
-})

package/src/propertyConservation.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { columnCountsFromColumns } from './columnCounts.ts'
-import { calculatePropertyConservation } from './propertyConservation.ts'
-
-function propertyConservation(columns: string[]) {
-  return calculatePropertyConservation(columnCountsFromColumns(columns))
-}
-
-describe('property conservation', () => {
-  test('an invariant column scores 1', () => {
-    expect(propertyConservation(['LLLL'])[0]).toBe(1)
-  })
-
-  test('a column varying only within one property class stays fully conserved', () => {
-    // L/I/V/M are all hydrophobic: identity varies but the property does not
-    expect(propertyConservation(['LIVM'])[0]).toBe(1)
-  })
-
-  test('mixing opposite-charge classes lowers the score', () => {
-    // K/R (positive) vs D/E (negative): two equally-sized classes
-    const score = propertyConservation(['KRDE'])[0]!
-    expect(score).toBeGreaterThan(0)
-    expect(score).toBeLessThan(1)
-  })
-
-  test('gaps reduce the score proportionally', () => {
-    const full = propertyConservation(['LLLL'])[0]!
-    const halfGapped = propertyConservation(['LL--'])[0]!
-    expect(halfGapped).toBeCloseTo(full * 0.5)
-  })
-
-  test('an all-gap column scores 0', () => {
-    expect(propertyConservation(['----'])[0]).toBe(0)
-  })
-})