react-msaview 6.4.2 → 7.0.0

package/src/domainBands.test.ts

@@ -1,122 +0,0 @@
-// @vitest-environment jsdom
-// The domain overlay resolves each annotation to the visible column span it is
-// drawn across once, on the model, instead of converting sequence positions
-// inside every canvas block. These tests pin that span (including across hidden
-// gappy columns) and the hit-test built on top of it.
-import { expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-// row `b` has a 4-residue insertion relative to `a`, which becomes a run of
-// mostly-gap columns that gap hiding can remove
-const msa = `>a
-MKLV----WYAC
->b
-MKLVQQQQWYAC`
-
-const gff = `##gff-version 3
-a	Pfam	protein_match	1	4	.	.	.	Name=PF00001;signature_desc=First
-a	Pfam	protein_match	5	8	.	.	.	Name=PF00002;signature_desc=Second`
-
-// row `b` only: PF00003 ends inside the insertion, PF00004 lies entirely within
-// it, so gap hiding puts one end and then both ends into hidden columns
-const insertionGff = `##gff-version 3
-b	Pfam	protein_match	4	8	.	.	.	Name=PF00003;signature_desc=Overlapping
-b	Pfam	protein_match	5	8	.	.	.	Name=PF00004;signature_desc=Inside`
-
-function makeModel() {
-  const model = MSAModelF().create({
-    id: 'domain-bands-test',
-    type: 'MsaView',
-    msaFormat: 'fasta',
-    height: 400,
-    data: { msa },
-  })
-  model.setWidth(800)
-  model.applyGFFText(gff)
-  return model
-}
-
-test('bands span the columns their residues occupy', () => {
-  const model = makeModel()
-  const bands = model.domainBands.get('a')!
-  expect(
-    bands.map(b => [b.annotation.accession, b.startCol, b.endCol]),
-  ).toEqual([
-    ['PF00001', 0, 4],
-    ['PF00002', 8, 12],
-  ])
-})
-
-test('bands follow the columns when gappy columns are hidden', () => {
-  const model = makeModel()
-  model.setHideGaps(true)
-  model.setAllowedGappyness(50)
-  // the 4 insertion columns are gaps in half the rows, so they are hidden and
-  // everything to their right shifts left by 4
-  expect(model.blanks).toEqual([4, 5, 6, 7])
-  const bands = model.domainBands.get('a')!
-  expect(bands.map(b => [b.startCol, b.endCol])).toEqual([
-    [0, 4],
-    [4, 8],
-  ])
-})
-
-test('a band whose end lands in a hidden column keeps its visible part', () => {
-  const model = makeModel()
-  model.applyGFFText(insertionGff)
-  expect(model.domainBands.get('b')!.map(b => [b.startCol, b.endCol])).toEqual([
-    [3, 8],
-    [4, 8],
-  ])
-
-  model.setHideGaps(true)
-  model.setAllowedGappyness(50)
-  expect(model.blanks).toEqual([4, 5, 6, 7])
-  // PF00003 covers V + the 4 hidden Qs, so only the V column survives; PF00004
-  // is nothing but hidden columns and drops out entirely
-  expect(model.domainBands.get('b')!.map(b => [b.startCol, b.endCol])).toEqual([
-    [3, 4],
-  ])
-})
-
-test('mouseOverDomains hit-tests against the drawn span', () => {
-  const model = makeModel()
-  const rowIndex = model.rowNames.indexOf('a')
-
-  model.setMousePos(0, rowIndex)
-  expect(model.mouseOverDomains.map(d => d.accession)).toEqual(['PF00001'])
-
-  // the columns between the two domains are the insertion gap: no domain there
-  model.setMousePos(5, rowIndex)
-  expect(model.mouseOverDomains).toEqual([])
-
-  model.setMousePos(8, rowIndex)
-  expect(model.mouseOverDomains.map(d => d.accession)).toEqual(['PF00002'])
-
-  // end column is exclusive
-  model.setMousePos(12, rowIndex)
-  expect(model.mouseOverDomains).toEqual([])
-
-  // the other row has no annotations of its own
-  model.setMousePos(0, model.rowNames.indexOf('b'))
-  expect(model.mouseOverDomains).toEqual([])
-})
-
-test('filtering a domain off removes its band', () => {
-  const model = makeModel()
-  model.setFilter('PF00001', false)
-  expect(model.domainBands.get('a')!.map(b => b.annotation.accession)).toEqual([
-    'PF00002',
-  ])
-})
-
-test('highlighted columns collapse into contiguous runs', () => {
-  const model = makeModel()
-  model.setHighlightedColumns([5, 1, 2, 3, 9])
-  expect(model.highlightedColumnRuns).toEqual([
-    { start: 1, end: 3 },
-    { start: 5, end: 5 },
-    { start: 9, end: 9 },
-  ])
-})

package/src/domainLetterColor.test.ts

@@ -1,80 +0,0 @@
-// @vitest-environment jsdom
-//
-// Letters drawn on top of the domain overlay take their color from the box
-// underneath them. The overlay paints bands largest-first, so with nested
-// signatures -- routine in InterProScan output, where a family encloses a
-// domain -- the box actually visible at a column is the *last* one painted,
-// not the first one covering it.
-import { expect, test } from 'vitest'
-
-import { domainBandCursor } from './components/msa/domainBandCursor.ts'
-import MSAModelF from './model.ts'
-
-const row = 'ACDEFGHIKLMNPQRSTVWY'
-const msa = `>seq1\n${row}\n>seq2\n${row}`
-
-// PF_OUTER spans the whole row, PF_INNER sits inside it. tidyInterProAnnotations
-// orders by length descending, so the outer band paints first and the inner one
-// covers it.
-const gff = `##gff-version 3
-seq1\tPfam\tprotein_match\t1\t20\t.\t.\t.\tName=PF_OUTER;signature_desc=Outer
-seq1\tPfam\tprotein_match\t8\t12\t.\t.\t.\tName=PF_INNER;signature_desc=Inner`
-
-function makeModel() {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    msaFormat: 'fasta',
-    data: { msa },
-  })
-  model.setWidth(800)
-  model.applyGFFText(gff)
-  return model
-}
-
-function sweep(model: ReturnType<typeof makeModel>, from = 0) {
-  const bandAt = domainBandCursor(model.domainBandsByStart.get('seq1'))
-  const out: (string | undefined)[] = []
-  for (let col = from; col < 20; col++) {
-    out.push(bandAt(col)?.annotation.accession)
-  }
-  return out
-}
-
-test('the overlay paints largest-first, so stackIndex is paint order', () => {
-  const bands = makeModel().domainBands.get('seq1')!
-  expect(bands.map(b => [b.annotation.accession, b.stackIndex])).toEqual([
-    ['PF_OUTER', 0],
-    ['PF_INNER', 1],
-  ])
-})
-
-test('a nested band wins the columns it covers', () => {
-  const model = makeModel()
-  // PF_INNER is seq positions 8-12 (1-based), i.e. columns 7..11
-  expect(sweep(model)).toEqual([
-    ...Array.from({ length: 7 }, () => 'PF_OUTER'),
-    ...Array.from({ length: 5 }, () => 'PF_INNER'),
-    ...Array.from({ length: 8 }, () => 'PF_OUTER'),
-  ])
-})
-
-test('a sweep starting mid-block picks up bands opened before it', () => {
-  // canvas blocks start at arbitrary columns, so the cursor has to catch up on
-  // its first call rather than assuming it began at column 0
-  const model = makeModel()
-  expect(sweep(model, 9)).toEqual([
-    'PF_INNER',
-    'PF_INNER',
-    'PF_INNER',
-    ...Array.from({ length: 8 }, () => 'PF_OUTER'),
-  ])
-})
-
-test('columns outside every band have no covering band', () => {
-  const model = makeModel()
-  model.setFilter('PF_OUTER', false)
-  const bandAt = domainBandCursor(model.domainBandsByStart.get('seq1'))
-  expect(bandAt(0)).toBeUndefined()
-  expect(bandAt(9)?.annotation.accession).toBe('PF_INNER')
-  expect(bandAt(19)).toBeUndefined()
-})

package/src/exportFileName.test.ts

@@ -1,40 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { exportFileName } from './exportFileName.ts'
-
-test('takes the alignment file name and swaps the extension', () => {
-  expect(
-    exportFileName(
-      {
-        uri: 'https://example.org/data/PF00069.stock?dl=1',
-        locationType: 'UriLocation',
-      },
-      'svg',
-    ),
-  ).toBe('PF00069.svg')
-  expect(
-    exportFileName(
-      {
-        localPath: 'C:\\aligns\\hemoglobin.fa',
-        locationType: 'LocalPathLocation',
-      },
-      'svg',
-    ),
-  ).toBe('hemoglobin.svg')
-  expect(
-    exportFileName(
-      { blobId: 'b1', name: 'pasted.aln', locationType: 'BlobLocation' },
-      'svg',
-    ),
-  ).toBe('pasted.svg')
-})
-
-test('falls back to a plain name without a file', () => {
-  expect(exportFileName(undefined, 'svg')).toBe('image.svg')
-  expect(
-    exportFileName(
-      { uri: 'https://example.org/', locationType: 'UriLocation' },
-      'svg',
-    ),
-  ).toBe('image.svg')
-})

package/src/fetchUtils.test.ts

@@ -1,83 +0,0 @@
-import { openLocation } from '@jbrowse/core/util/io'
-import { describe, expect, test } from 'vitest'
-
-import { fetchTextWithProgress, isAbortError } from './fetchUtils.ts'
-
-import type { FetchStatus } from './fetchUtils.ts'
-
-const loc = openLocation({
-  uri: 'http://example.com/data.fa',
-  locationType: 'UriLocation',
-})
-
-describe('fetchTextWithProgress', () => {
-  test('reports progress messages then clears status', async () => {
-    const statuses: (FetchStatus | undefined)[] = []
-    const result = await fetchTextWithProgress(
-      loc,
-      s => statuses.push(s),
-      async (_loc, opts) => {
-        opts.statusCallback('Downloading file')
-        opts.statusCallback('')
-        return 'GREETINGS'
-      },
-    )
-    expect(result).toBe('GREETINGS')
-    expect(statuses.map(s => s?.msg)).toEqual([
-      'Downloading file',
-      undefined,
-      undefined,
-    ])
-  })
-
-  test('reports the message from a determinate progress status', async () => {
-    const statuses: (FetchStatus | undefined)[] = []
-    await fetchTextWithProgress(
-      loc,
-      s => statuses.push(s),
-      async (_loc, opts) => {
-        opts.statusCallback({
-          message: 'Downloading file',
-          current: 5,
-          total: 10,
-        })
-        return 'GREETINGS'
-      },
-    )
-    expect(statuses[0]?.msg).toBe('Downloading file')
-  })
-
-  test('clears status even when the fetch throws', async () => {
-    const statuses: (FetchStatus | undefined)[] = []
-    await expect(
-      fetchTextWithProgress(
-        loc,
-        s => statuses.push(s),
-        async () => {
-          throw new Error('network down')
-        },
-      ),
-    ).rejects.toThrow('network down')
-    expect(statuses.at(-1)).toBeUndefined()
-  })
-
-  test('onCancel aborts the underlying request', async () => {
-    const statuses: (FetchStatus | undefined)[] = []
-    const promise = fetchTextWithProgress(
-      loc,
-      s => statuses.push(s),
-      (_loc, opts) =>
-        new Promise<string>((_resolve, reject) => {
-          opts.statusCallback('Downloading file')
-          opts.signal.addEventListener('abort', () => {
-            reject(new DOMException('Aborted', 'AbortError'))
-          })
-        }),
-    )
-
-    statuses.find(s => s?.onCancel)?.onCancel?.()
-
-    await expect(promise).rejects.toSatisfy(isAbortError)
-    expect(statuses.at(-1)).toBeUndefined()
-  })
-})

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