react-msaview 6.5.0 → 8.0.0

package/src/flatToTree.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { flatToTree } from './flatToTree.ts'
-
-describe('flatToTree', () => {
-  test('builds a tree from a flat parent list', () => {
-    const root = flatToTree([
-      { id: 0 },
-      { id: 1, parent: 0 },
-      { id: 2, parent: 0 },
-      { id: 3, parent: 1 },
-    ])
-    expect(root.id).toBe('0')
-    expect(root.children.map(c => c.id)).toEqual(['1', '2'])
-    expect(root.children[0]!.children.map(c => c.id)).toEqual(['3'])
-  })
-
-  test('carries the label and branch length of a BioTreeContainer node', () => {
-    const root = flatToTree([
-      { id: 0, label: 'Multiple organisms' },
-      {
-        id: 1,
-        parent: 0,
-        label: 'sodium/glucose cotransporter 4',
-        dist: '0.5',
-      },
-      { id: 2, parent: 0 },
-    ])
-    expect(root.name).toBe('Multiple organisms')
-    expect(root.children[0]).toMatchObject({
-      name: 'sodium/glucose cotransporter 4',
-      length: 0.5,
-    })
-    // no label falls back to the id, and no dist leaves the length unset
-    expect(root.children[1]!.name).toBe('2')
-    expect(root.children[1]!.length).toBeUndefined()
-  })
-
-  test('throws on empty input rather than returning undefined', () => {
-    expect(() => flatToTree([])).toThrow(/no root/)
-  })
-
-  test('throws when every node has a parent (cycle) rather than returning undefined', () => {
-    expect(() =>
-      flatToTree([
-        { id: 0, parent: 1 },
-        { id: 1, parent: 0 },
-      ]),
-    ).toThrow(/no root/)
-  })
-})

package/src/hierarchy.test.ts

@@ -1,228 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import {
-  calcDepthToLeaf,
-  collapse,
-  collapsedSubtreeMaxLength,
-  find,
-  findMaxBranchLen,
-  hierarchy,
-  leaves,
-  maxLength,
-  setBrLength,
-  sort,
-  sum,
-} from './hierarchy.ts'
-
-import type { NodeWithIds } from './types.ts'
-
-// Builds a fully unbalanced "caterpillar" tree of the given depth: each internal
-// node has one leaf child and one internal child. Recursion over this would blow
-// the call stack; the iterative traversals must handle it.
-function makeDeepTree(depth: number): NodeWithIds {
-  let node: NodeWithIds = { id: 'leaf0', name: 'leaf0', children: [] }
-  for (let i = 1; i <= depth; i++) {
-    node = {
-      id: `node${i}`,
-      name: `node${i}`,
-      length: 1,
-      children: [{ id: `leaf${i}`, name: `leaf${i}`, children: [] }, node],
-    }
-  }
-  return node
-}
-
-function makeTree(): NodeWithIds {
-  return {
-    id: 'root',
-    name: 'root',
-    children: [
-      {
-        id: 'A',
-        name: 'A',
-        children: [
-          { id: 'A1', name: 'A1', children: [] },
-          { id: 'A2', name: 'A2', children: [] },
-        ],
-      },
-      {
-        id: 'B',
-        name: 'B',
-        children: [
-          { id: 'B1', name: 'B1', children: [] },
-          { id: 'B2', name: 'B2', children: [] },
-        ],
-      },
-    ],
-  }
-}
-
-describe('hierarchy', () => {
-  test('builds hierarchy from tree data', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    expect(h.data.id).toBe('root')
-    expect(h.children?.length).toBe(2)
-    expect(h.height).toBe(2)
-  })
-
-  test('sets parent references', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    expect(h.parent).toBeNull()
-    expect(h.children![0]!.parent).toBe(h)
-    expect(h.children![0]!.children![0]!.parent).toBe(h.children![0])
-  })
-})
-
-describe('leaves', () => {
-  test('returns leaf nodes', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const l = leaves(h)
-    expect(l.map(n => n.data.name)).toEqual(['A1', 'A2', 'B1', 'B2'])
-  })
-})
-
-describe('find', () => {
-  test('finds node by id', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const node = find(h, n => n.data.id === 'B1')
-    expect(node?.data.name).toBe('B1')
-  })
-
-  test('returns undefined for missing id', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    expect(find(h, n => n.data.id === 'Z')).toBeUndefined()
-  })
-})
-
-describe('collapse', () => {
-  test('hides children of a branch node', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const nodeA = find(h, n => n.data.id === 'A')!
-    collapse(nodeA)
-    expect(nodeA.children).toBeNull()
-    expect(nodeA._children?.length).toBe(2)
-    expect(leaves(h).map(n => n.data.name)).toEqual(['A', 'B1', 'B2'])
-  })
-
-  test('does nothing on a leaf node', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const leaf = find(h, n => n.data.id === 'A1')!
-    collapse(leaf)
-    expect(leaves(h).map(n => n.data.name)).toEqual(['A1', 'A2', 'B1', 'B2'])
-  })
-
-  test('preserves the subtree depth so the layout stays stable', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const nodeA = find(h, n => n.data.id === 'A')!
-    collapse(nodeA)
-    // the collapsed node keeps its real depth (1) rather than becoming a depth-0
-    // leaf, so the cladogram apex sits at the true branch point
-    expect(nodeA.depthToLeaf).toBe(1)
-    // and the root still measures the tree as 2 deep, so collapsing A does not
-    // horizontally shift the rest of the tree
-    expect(calcDepthToLeaf(h)).toBe(2)
-  })
-})
-
-describe('collapsedSubtreeMaxLength', () => {
-  // root → A(1) → [ A1(2), C(3) → [ C1(1), C2(10) ] ]
-  function makeLenTree(): NodeWithIds {
-    return {
-      id: 'root',
-      name: 'root',
-      children: [
-        {
-          id: 'A',
-          name: 'A',
-          length: 1,
-          children: [
-            { id: 'A1', name: 'A1', length: 2, children: [] },
-            {
-              id: 'C',
-              name: 'C',
-              length: 3,
-              children: [
-                { id: 'C1', name: 'C1', length: 1, children: [] },
-                { id: 'C2', name: 'C2', length: 10, children: [] },
-              ],
-            },
-          ],
-        },
-      ],
-    }
-  }
-
-  test('cumulative branch length to the farthest tip below a node', () => {
-    const h = hierarchy(makeLenTree(), d => d.children)
-    const nodeA = find(h, n => n.data.id === 'A')!
-    collapse(nodeA)
-    // excludes A's own branch: farthest tip C2 = 3 + 10 = 13, vs A1 = 2
-    expect(collapsedSubtreeMaxLength(nodeA)).toBe(13)
-  })
-
-  test('returns zero for a node with no descendants', () => {
-    const h = hierarchy(makeLenTree(), d => d.children)
-    const leaf = find(h, n => n.data.id === 'A1')!
-    expect(collapsedSubtreeMaxLength(leaf)).toBe(0)
-  })
-})
-
-describe('leaf removal via parent.children filter', () => {
-  test('removing a leaf from its parent hides it from leaves()', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const leaf = find(h, n => n.data.id === 'A1')!
-    leaf.parent!.children = leaf.parent!.children!.filter(
-      c => c.data.id !== 'A1',
-    )
-    expect(leaves(h).map(n => n.data.name)).toEqual(['A2', 'B1', 'B2'])
-  })
-
-  test('removing all leaves from a branch makes the branch a leaf', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    const nodeA = find(h, n => n.data.id === 'A')!
-    nodeA.children = []
-    expect(leaves(h).map(n => n.data.name)).toEqual(['B1', 'B2'])
-  })
-})
-
-describe('sort', () => {
-  test('sorts children', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    sort(h, (a, b) => b.data.name.localeCompare(a.data.name))
-    expect(h.children!.map(c => c.data.name)).toEqual(['B', 'A'])
-  })
-})
-
-describe('sum', () => {
-  test('computes leaf counts', () => {
-    const h = hierarchy(makeTree(), d => d.children)
-    sum(h, d => (d.children.length > 0 ? 0 : 1))
-    expect(h.value).toBe(4)
-    expect(find(h, n => n.data.id === 'A')?.value).toBe(2)
-  })
-})
-
-describe('deep (caterpillar) trees do not overflow the stack', () => {
-  const depth = 100_000
-
-  test('build, height, leaf count, and ordering', () => {
-    const h = hierarchy(makeDeepTree(depth), d => d.children)
-    expect(h.height).toBe(depth)
-    const l = leaves(h)
-    expect(l.length).toBe(depth + 1)
-    // each level contributes its own leafN before descending; deepest leaf last
-    expect(l[0]!.data.name).toBe(`leaf${depth}`)
-    expect(l.at(-1)!.data.name).toBe('leaf0')
-  })
-
-  test('accumulation helpers (sum, find, maxLength, setBrLength, depth)', () => {
-    const h = hierarchy(makeDeepTree(depth), d => d.children)
-    sum(h, d => (d.children.length > 0 ? 0 : 1))
-    expect(h.value).toBe(depth + 1)
-    expect(find(h, n => n.data.id === 'leaf0')?.data.name).toBe('leaf0')
-    expect(maxLength(h)).toBe(depth)
-    expect(calcDepthToLeaf(h)).toBe(depth)
-    setBrLength(h, 0, 1)
-    expect(findMaxBranchLen(h)).toBe(depth)
-  })
-})

package/src/highlights.test.ts

@@ -1,70 +0,0 @@
-// @vitest-environment jsdom
-import { expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-// seq2 skips columns 3-4 of the alignment, so its residue 3 sits at global
-// column 5 (1-based). The all-gap column 4 is what hideGaps removes.
-const msa = `>seq1
-AC-DEFG
->seq2
-AC--EFG
->seq3
-AC-DEFG`
-
-function makeModel(highlights: Record<string, unknown>[]) {
-  const model = MSAModelF().create({
-    id: 'highlights-test',
-    type: 'MsaView',
-    msaFormat: 'fasta',
-    data: { msa },
-    highlights,
-  })
-  model.setWidth(800)
-  return model
-}
-
-test('a column span is 1-based and lands on 0-based visible columns', () => {
-  const model = makeModel([{ start: 2, end: 4, label: 'x' }])
-  expect(model.resolvedHighlights).toEqual([
-    { startCol: 1, endCol: 3, rowIndices: [], label: 'x', color: undefined },
-  ])
-})
-
-test('a residue span projects through the named row', () => {
-  const model = makeModel([{ row: 'seq2', start: 3, end: 4 }])
-  expect(model.resolvedHighlights[0]).toMatchObject({ startCol: 4, endCol: 5 })
-})
-
-test('hidden columns shift a span and drop one they swallow whole', () => {
-  const model = makeModel([
-    { start: 5, end: 6, label: 'after' },
-    { start: 3, end: 3, label: 'gone' },
-    { row: 'seq2', start: 2, end: 3, label: 'across' },
-  ])
-  model.setHideGaps(true)
-  model.setAllowedGappyness(50)
-  expect(model.blanks).toEqual([2])
-  expect(
-    model.resolvedHighlights.map(h => [h.label, h.startCol, h.endCol]),
-  ).toEqual([
-    ['after', 3, 4],
-    ['across', 1, 3],
-  ])
-})
-
-test('a row set resolves to row indices and ignores unknown names', () => {
-  const model = makeModel([{ rows: ['seq3', 'nope', 'seq1'], color: 'red' }])
-  expect(model.resolvedHighlights).toEqual([
-    { rowIndices: [2, 0], label: undefined, color: 'red' },
-  ])
-  expect(makeModel([{ rows: ['nope'] }]).resolvedHighlights).toEqual([])
-})
-
-test('setHighlights replaces the list and reset clears it', () => {
-  const model = makeModel([])
-  model.setHighlights([{ start: 1, end: 1 }])
-  expect(model.highlights).toHaveLength(1)
-  model.reset()
-  expect(model.highlights).toHaveLength(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()
-  }
-}