react-msaview 6.5.0 → 8.0.0

package/src/renderToSvg.test.tsx

@@ -1,65 +0,0 @@
-// @vitest-environment jsdom
-//
-// Layout and palette of the exported figure itself, as opposed to what any one
-// layer draws inside it.
-import { createJBrowseTheme } from '@jbrowse/core/ui/theme'
-import { beforeAll, expect, test } from 'vitest'
-
-import { renderToSvg } from './renderToSvg.tsx'
-import {
-  createTestModel,
-  installSvgTestEnv,
-  syntheticProteinMsa,
-} from './svgTestUtil.ts'
-
-beforeAll(() => {
-  installSvgTestEnv()
-})
-
-function makeModel({ rows = 60, cols = 400 } = {}) {
-  return createTestModel({ data: { msa: syntheticProteinMsa(rows, cols) } })
-}
-
-const rootRect = (svg: string) => /<rect[^>]*height="100%"[^>]*>/.exec(svg)?.[0]
-
-test('the page takes the theme background, not a hardcoded white', async () => {
-  const model = makeModel()
-  const dark = createJBrowseTheme({ palette: { mode: 'dark' } })
-  expect(dark.palette.background.default).not.toBe('white')
-
-  const svg = await renderToSvg(model, { theme: dark, exportType: 'entire' })
-
-  // the layers below draw in theme colors: text.primary is near-white in a dark
-  // theme, so a white page would export white on white
-  expect(rootRect(svg)).toContain(`fill="${dark.palette.background.default}"`)
-})
-
-test('a viewport export is the alignment canvas, not the whole widget', async () => {
-  const model = makeModel()
-  expect(model.showHorizontalScrollbar).toBe(true)
-  expect(model.showVerticalScrollbar).toBe(true)
-
-  const svg = await renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'viewport',
-    includeMinimap: true,
-  })
-
-  // the widget box also covers the resize handle and the scrollbars; exporting
-  // it drew the rows and columns those hide
-  const { treeAreaWidth, msaCanvasWidth, msaAreaHeight, minimapHeight } = model
-  expect(svg).toContain(`width="${treeAreaWidth + msaCanvasWidth}"`)
-  expect(svg).toContain(`height="${msaAreaHeight + minimapHeight}"`)
-  expect(msaAreaHeight + minimapHeight).toBe(model.height)
-})
-
-test('no attribute is serialized as the string "undefined"', async () => {
-  const model = makeModel({ rows: 4, cols: 20 })
-  const svg = await renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'entire',
-  })
-
-  expect(svg).toContain('<text')
-  expect(svg).not.toContain('="undefined"')
-})

package/src/reset.test.ts

@@ -1,61 +0,0 @@
-import { expect, test } from 'vitest'
-
-import stateModelFactory from './model.ts'
-
-const MsaView = stateModelFactory()
-
-function loaded() {
-  const model = MsaView.create({
-    type: 'MsaView',
-    data: { msa: '>a\nAC\n>b\nAC\n>c\nAC\n>d\nAC', tree: '((a,b),(c,d));' },
-  })
-  model.setWidth(1000)
-  return model
-}
-
-test('reset returns to the import form', () => {
-  const model = loaded()
-  expect(model.dataInitialized).toBe(true)
-  model.reset()
-  expect(model.dataInitialized).toBe(false)
-})
-
-// generateNodeIds derives ids from the path, so 'node-0-0-1' is the root's
-// first child in EVERY tree. Carrying collapsed/showOnly across a reset opens
-// the next file collapsed, or focused on a subtree, with nothing on screen
-// saying why
-test('reset drops view state that names the old data', () => {
-  const model = loaded()
-  const innerNode = model.hierarchy.children![0]!.data.id
-  model.toggleCollapsed(innerNode)
-  model.setShowOnly(innerNode)
-  model.drawRelativeTo('a')
-  model.setHighlightedColumns([0, 1])
-  model.setMousePos(1, 1)
-  model.setMouseClickPos(1, 1)
-  model.setHoveredTreeNode(innerNode)
-
-  model.reset()
-
-  expect([...model.collapsed]).toEqual([])
-  expect(model.showOnly).toBeUndefined()
-  expect(model.relativeTo).toBeUndefined()
-  expect(model.highlightedColumns).toBeUndefined()
-  expect(model.mouseCol).toBeUndefined()
-  expect(model.mouseClickCol).toBeUndefined()
-  expect(model.hoveredTreeNode).toBeUndefined()
-})
-
-test('a file opened after a reset is not collapsed by the previous one', () => {
-  const model = loaded()
-  model.toggleCollapsed(model.hierarchy.children![0]!.data.id)
-  expect(model.numRows).toBeLessThan(4)
-
-  model.reset()
-  model.setData({
-    msa: '>x\nGT\n>y\nGT\n>z\nGT\n>w\nGT',
-    tree: '((x,y),(z,w));',
-  })
-  expect(model.numRows).toBe(4)
-  expect(model.rowNames).toEqual(['x', 'y', 'z', 'w'])
-})

package/src/rowCoordinateCalculations.test.ts

@@ -1,211 +0,0 @@
-import { expect, test } from 'vitest'
-
-import {
-  globalColToVisibleCol,
-  visibleColToGlobalCol,
-  visibleColToSeqPos,
-} from './rowCoordinateCalculations.ts'
-
-// Tests for visibleColToGlobalCol (visible → global)
-test('visibleColToGlobalCol with blanks at positions [2, 5, 8]', () => {
-  const blanks = [2, 5, 8]
-  ;(
-    [
-      [0, 0],
-      [1, 1],
-      [2, 3],
-      [3, 4],
-      [4, 6],
-      [5, 7],
-      [6, 9],
-      [7, 10],
-    ] as const
-  ).forEach(r => {
-    expect(visibleColToGlobalCol(blanks, r[0])).toBe(r[1])
-  })
-})
-
-test('visibleColToGlobalCol with no blanks', () => {
-  const blanks: number[] = []
-  ;(
-    [
-      [0, 0],
-      [1, 1],
-      [5, 5],
-      [10, 10],
-    ] as const
-  ).forEach(r => {
-    expect(visibleColToGlobalCol(blanks, r[0])).toBe(r[1])
-  })
-})
-
-test('visibleColToGlobalCol with consecutive blanks', () => {
-  const blanks = [2, 3, 4, 7, 8]
-  ;(
-    [
-      [0, 0],
-      [1, 1],
-      [2, 5], // After position 1, skip 3 blanks (2,3,4)
-      [3, 6], // Next position
-      [4, 9], // After position 3, skip 2 blanks (7,8)
-      [5, 10],
-    ] as const
-  ).forEach(r => {
-    expect(visibleColToGlobalCol(blanks, r[0])).toBe(r[1])
-  })
-})
-
-test('visibleColToGlobalCol with blanks at the beginning', () => {
-  const blanks = [1, 2, 5]
-  ;(
-    [
-      [0, 0],
-      [1, 3], // After position 0, skip 2 blanks (1,2)
-      [2, 4],
-      [3, 6], // After position 2, skip 1 blank (5)
-      [4, 7],
-    ] as const
-  ).forEach(r => {
-    expect(visibleColToGlobalCol(blanks, r[0])).toBe(r[1])
-  })
-})
-
-test('visibleColToGlobalCol with position exceeding blanks array', () => {
-  const blanks = [2, 5]
-  ;(
-    [
-      [0, 0],
-      [1, 1],
-      [2, 3], // After position 1, skip 1 blank (2)
-      [3, 4],
-      [4, 6], // After position 3, skip 1 blank (5)
-      [10, 12], // Far beyond blanks array
-    ] as const
-  ).forEach(r => {
-    expect(visibleColToGlobalCol(blanks, r[0])).toBe(r[1])
-  })
-})
-
-// Tests for globalColToVisibleCol (global → visible)
-test('globalColToVisibleCol with blanks at positions [2, 5, 8]', () => {
-  const blanks = [2, 5, 8]
-  // Inverse of visibleColToGlobalCol
-  expect(globalColToVisibleCol(blanks, 0)).toBe(0)
-  expect(globalColToVisibleCol(blanks, 1)).toBe(1)
-  expect(globalColToVisibleCol(blanks, 2)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 3)).toBe(2)
-  expect(globalColToVisibleCol(blanks, 4)).toBe(3)
-  expect(globalColToVisibleCol(blanks, 5)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 6)).toBe(4)
-  expect(globalColToVisibleCol(blanks, 7)).toBe(5)
-  expect(globalColToVisibleCol(blanks, 8)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 9)).toBe(6)
-  expect(globalColToVisibleCol(blanks, 10)).toBe(7)
-})
-
-test('globalColToVisibleCol with no blanks', () => {
-  const blanks: number[] = []
-  expect(globalColToVisibleCol(blanks, 0)).toBe(0)
-  expect(globalColToVisibleCol(blanks, 5)).toBe(5)
-  expect(globalColToVisibleCol(blanks, 10)).toBe(10)
-})
-
-test('globalColToVisibleCol with consecutive blanks', () => {
-  const blanks = [2, 3, 4, 7, 8]
-  expect(globalColToVisibleCol(blanks, 0)).toBe(0)
-  expect(globalColToVisibleCol(blanks, 1)).toBe(1)
-  expect(globalColToVisibleCol(blanks, 2)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 3)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 4)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 5)).toBe(2)
-  expect(globalColToVisibleCol(blanks, 6)).toBe(3)
-  expect(globalColToVisibleCol(blanks, 7)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 8)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 9)).toBe(4)
-  expect(globalColToVisibleCol(blanks, 10)).toBe(5)
-})
-
-// Tests for visibleColToSeqPos (visible column → sequence position)
-test('visibleColToSeqPos returns sequence position or undefined for gaps', () => {
-  const seq = 'AC--GT--CT'
-  expect(visibleColToSeqPos({ seq, visibleCol: 0, blanks: [] })).toBe(0)
-  expect(visibleColToSeqPos({ seq, visibleCol: 1, blanks: [] })).toBe(1)
-  expect(visibleColToSeqPos({ seq, visibleCol: 2, blanks: [] })).toBe(undefined)
-  expect(visibleColToSeqPos({ seq, visibleCol: 3, blanks: [] })).toBe(undefined)
-  expect(visibleColToSeqPos({ seq, visibleCol: 4, blanks: [] })).toBe(2)
-  expect(visibleColToSeqPos({ seq, visibleCol: 5, blanks: [] })).toBe(3)
-  expect(visibleColToSeqPos({ seq, visibleCol: 6, blanks: [] })).toBe(undefined)
-  expect(visibleColToSeqPos({ seq, visibleCol: 7, blanks: [] })).toBe(undefined)
-  expect(visibleColToSeqPos({ seq, visibleCol: 8, blanks: [] })).toBe(4)
-  expect(visibleColToSeqPos({ seq, visibleCol: 9, blanks: [] })).toBe(5)
-})
-
-// Round-trip tests: visible → global → visible should be identity for valid columns
-test('round-trip: visibleColToGlobalCol and globalColToVisibleCol are inverses', () => {
-  const blanks = [2, 5, 8]
-  // For each visible column, going to global and back should return the same value
-  for (let visibleCol = 0; visibleCol < 10; visibleCol++) {
-    const globalCol = visibleColToGlobalCol(blanks, visibleCol)
-    const backToVisible = globalColToVisibleCol(blanks, globalCol)
-    expect(backToVisible).toBe(visibleCol)
-  }
-})
-
-test('round-trip: globalColToVisibleCol and visibleColToGlobalCol for non-hidden columns', () => {
-  const blanks = [2, 5, 8]
-  // For each global column that is NOT hidden, going to visible and back should return the same value
-  for (let globalCol = 0; globalCol < 15; globalCol++) {
-    const visibleCol = globalColToVisibleCol(blanks, globalCol)
-    if (visibleCol !== undefined) {
-      const backToGlobal = visibleColToGlobalCol(blanks, visibleCol)
-      expect(backToGlobal).toBe(globalCol)
-    }
-  }
-})
-
-// Edge case: blanks at position 0
-test('globalColToVisibleCol with blank at position 0', () => {
-  const blanks = [0, 1, 5]
-  expect(globalColToVisibleCol(blanks, 0)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 1)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 2)).toBe(0) // First visible column
-  expect(globalColToVisibleCol(blanks, 3)).toBe(1)
-  expect(globalColToVisibleCol(blanks, 4)).toBe(2)
-  expect(globalColToVisibleCol(blanks, 5)).toBe(undefined) // Hidden
-  expect(globalColToVisibleCol(blanks, 6)).toBe(3)
-})
-
-test('visibleColToGlobalCol with blank at position 0', () => {
-  const blanks = [0, 1, 5]
-  expect(visibleColToGlobalCol(blanks, 0)).toBe(2) // Skips 0, 1
-  expect(visibleColToGlobalCol(blanks, 1)).toBe(3)
-  expect(visibleColToGlobalCol(blanks, 2)).toBe(4)
-  expect(visibleColToGlobalCol(blanks, 3)).toBe(6) // Skips 5
-})
-
-// Edge case: all columns before a position are blanks
-test('globalColToVisibleCol with many leading blanks', () => {
-  const blanks = [0, 1, 2, 3, 4]
-  expect(globalColToVisibleCol(blanks, 0)).toBe(undefined)
-  expect(globalColToVisibleCol(blanks, 4)).toBe(undefined)
-  expect(globalColToVisibleCol(blanks, 5)).toBe(0) // First visible
-  expect(globalColToVisibleCol(blanks, 6)).toBe(1)
-  expect(globalColToVisibleCol(blanks, 10)).toBe(5)
-})
-
-// Test visibleColToSeqPos with blanks (combined gap hiding and row gaps)
-test('visibleColToSeqPos with both blanks and row gaps', () => {
-  // Sequence: A-C-G (global cols 0,1,2,3,4)
-  // If blanks = [1, 3], visible sequence becomes: A C G (visible cols 0,1,2)
-  const seq = 'A-C-G'
-  const blanks = [1, 3]
-
-  // Visible col 0 → global col 0 → 'A' → seqPos 0
-  expect(visibleColToSeqPos({ seq, visibleCol: 0, blanks })).toBe(0)
-
-  // Visible col 1 → global col 2 → 'C' → seqPos 1
-  expect(visibleColToSeqPos({ seq, visibleCol: 1, blanks })).toBe(1)
-
-  // Visible col 2 → global col 4 → 'G' → seqPos 2
-  expect(visibleColToSeqPos({ seq, visibleCol: 2, blanks })).toBe(2)
-})

package/src/rowSpace.test.ts

@@ -1,46 +0,0 @@
-// @vitest-environment jsdom
-import { expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-// the tree names a tip the alignment has no sequence for. It still occupies a
-// row of vertical space (drawn blank), so anything that maps y-pixels to rows has
-// to count it, or the last row becomes unhoverable and fit-to-height overshoots.
-const msa = `>a
-ACGT
->b
-ACGT`
-const tree = '((a:1,b:1):1,ghost:1);'
-
-function makeModel() {
-  const model = MSAModelF().create({
-    id: 'row-space-test',
-    type: 'MsaView',
-    msaFormat: 'fasta',
-    height: 400,
-    data: { msa, tree },
-  })
-  model.setWidth(800)
-  return model
-}
-
-test('row space counts tree leaves, not just rows with sequence', () => {
-  const model = makeModel()
-  expect(model.rowNames).toEqual(['a', 'b', 'ghost'])
-  expect(model.rows.map(r => r[0])).toEqual(['a', 'b'])
-  expect(model.numRows).toBe(3)
-  expect(model.totalHeight).toBe(3 * model.rowHeight)
-})
-
-test('the last row is addressable', () => {
-  const model = makeModel()
-  const lastRow = model.numRows - 1
-  model.setMousePos(0, lastRow)
-  expect(model.mouseOverRowName).toBe('ghost')
-})
-
-test('fit vertically leaves every row on screen', () => {
-  const model = makeModel()
-  model.fitVertically()
-  expect(model.totalHeight).toBeLessThanOrEqual(model.msaAreaHeight)
-})

package/src/segmentOverlay.test.ts

@@ -1,70 +0,0 @@
-// Verifies that ordinal segment features (exons) from a GFF overlay are treated
-// as a numbered gene model — alternating two shades, labeled by number, and
-// kept out of the categorical color-key legend — while real domains keep a
-// distinct color + legend entry.
-import { expect, test } from 'vitest'
-
-import { segmentShades } from './constants.ts'
-import MSAModelF from './model.ts'
-
-const msa = `>human
-ACDEFGHIKLMNPQRSTVWYACDEFGHIKLMNPQRSTVWYACDEFGHIKLMNPQRSTVWY
->mouse
-ACDEFGHIKLMNPQRSTVWYACDEFGHIKLMNPQRSTVWYACDEFGHIKLMNPQRSTVWY`
-
-// three exons in CDS coordinates plus one real domain, deliberately out of
-// start order in the file to prove ordering is by position not file/length
-const gff = `##gff-version 3
-human	src	exon	41	60	.	.	.	ID=human.exon3;Name=exon-3
-human	src	exon	1	20	.	.	.	ID=human.exon1;Name=exon-1
-human	src	exon	21	40	.	.	.	ID=human.exon2;Name=exon-2
-human	Pfam	protein_match	5	35	.	.	.	Name=PF00069;signature_desc=Kinase`
-
-function makeModel() {
-  const model = MSAModelF().create({
-    id: 'segment-overlay-test',
-    type: 'MsaView',
-    height: 400,
-    msaFormat: 'fasta',
-    data: { msa },
-  })
-  model.setWidth(800)
-  model.applyGFFText(gff)
-  return model
-}
-
-test('exons are ordered by sequence position, domains kept separate', () => {
-  const model = makeModel()
-  expect(model.segmentDomainTypes.map(d => d.accession)).toEqual([
-    'exon-1',
-    'exon-2',
-    'exon-3',
-  ])
-  expect(model.categoricalDomainTypes.map(d => d.accession)).toEqual([
-    'PF00069',
-  ])
-})
-
-test('exons alternate two shades; domain gets its own color', () => {
-  const { fillPalette } = makeModel()
-  expect(fillPalette['exon-1']).toBe(segmentShades[0])
-  expect(fillPalette['exon-2']).toBe(segmentShades[1])
-  expect(fillPalette['exon-3']).toBe(segmentShades[0])
-  expect(fillPalette.PF00069).not.toBe(segmentShades[0])
-  expect(fillPalette.PF00069).not.toBe(segmentShades[1])
-})
-
-test('exons are labeled by their number', () => {
-  const { segmentLabels } = makeModel()
-  expect(segmentLabels.get('exon-1')).toBe('1')
-  expect(segmentLabels.get('exon-2')).toBe('2')
-  expect(segmentLabels.get('exon-3')).toBe('3')
-})
-
-test('legend lists only categorical domains, not exons', () => {
-  const model = makeModel()
-  for (const acc of ['exon-1', 'exon-2', 'exon-3', 'PF00069']) {
-    model.setFilter(acc, true)
-  }
-  expect(model.visibleDomainTypes.map(d => d.accession)).toEqual(['PF00069'])
-})

package/src/seqPosToGlobalCol.test.ts

@@ -1,59 +0,0 @@
-// seqPos -> global column, exercised through the model method rather than the
-// buildSeqPosIndex primitive behind it: the method is what
-// jbrowse-plugin-protein3d calls (see the cross-repo note in model.ts), and it
-// owns the past-the-end answers the index alone cannot give.
-import { describe, expect, test } from 'vitest'
-
-import MSAModelF from './model.ts'
-
-function colsOf(row: string, positions: number[]) {
-  const model = MSAModelF().create({
-    type: 'MsaView',
-    data: { msa: `>r\n${row}` },
-  })
-  model.setWidth(800)
-  return positions.map(pos => model.seqPosToGlobalCol('r', pos))
-}
-
-describe('seqPosToGlobalCol', () => {
-  test('is the identity when the row has no gaps', () => {
-    // 8 residues, so seqPos 8 is one past the end
-    expect(colsOf('ATGCATGC', [0, 3, 7, 8])).toEqual([0, 3, 7, 8])
-  })
-
-  test('skips gap columns', () => {
-    // Global: A(0) -(1) T(2) G(3) -(4) C(5) A(6) -(7) T(8) G(9) C(10)
-    // SeqPos: A(0)      T(1) G(2)      C(3) A(4)      T(5) G(6) C(7)
-    expect(colsOf('A-TG-CA-TGC', [0, 1, 2, 3, 4, 5, 6, 7, 8])).toEqual([
-      0, 2, 3, 5, 6, 8, 9, 10, 11,
-    ])
-  })
-
-  test('counts both gap characters, - and .', () => {
-    // Global: A(0) -(1) .(2) G(3) -(4) C(5) .(6)
-    // SeqPos: A(0)           G(1)      C(2)
-    expect(colsOf('A-.G-C.', [0, 1, 2, 3])).toEqual([0, 3, 5, 7])
-  })
-
-  test('handles leading and trailing gaps', () => {
-    expect(colsOf('--ACG', [0, 1, 2])).toEqual([2, 3, 4])
-    expect(colsOf('ACG--', [0, 1, 2, 3])).toEqual([0, 1, 2, 5])
-  })
-
-  test('an all-gap row reports position 0 at column 0', () => {
-    expect(colsOf('---..--', [0, 1])).toEqual([0, 7])
-  })
-
-  test('an empty row reports column 0', () => {
-    expect(colsOf('', [0])).toEqual([0])
-  })
-
-  test('an unknown row reports column 0', () => {
-    const model = MSAModelF().create({
-      type: 'MsaView',
-      data: { msa: '>r\nACGT' },
-    })
-    model.setWidth(800)
-    expect(model.seqPosToGlobalCol('nope', 2)).toBe(0)
-  })
-})

package/src/sequenceLogo.test.ts

@@ -1,88 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { columnCountsFromColumns } from './columnCounts.ts'
-import { columnLogoStack, maxBitsFor } from './sequenceLogo.ts'
-
-const dnaBits = maxBitsFor('dna')
-const aminoBits = maxBitsFor('amino')
-
-function stackOf(column: string, maxBits = dnaBits) {
-  return columnLogoStack(columnCountsFromColumns([column]), 0, maxBits)
-}
-
-test('maxBits is log2 of the alphabet', () => {
-  expect(maxBitsFor('dna')).toBe(2)
-  expect(maxBitsFor('rna')).toBe(2)
-  expect(maxBitsFor('amino')).toBeCloseTo(4.3219, 4)
-})
-
-test('a fully conserved column is one letter at the full height', () => {
-  const stack = stackOf('AAAA')
-  expect(stack).toHaveLength(1)
-  expect(stack[0]!.letter).toBe('A')
-  expect(stack[0]!.bits).toBeCloseTo(2, 10)
-})
-
-test('an even four-way column carries no information', () => {
-  expect(stackOf('ACGT')).toEqual([])
-})
-
-test('a two-way split is half the height, shared evenly', () => {
-  const stack = stackOf('AACC')
-  expect(stack.map(s => s.letter)).toEqual(['A', 'C'])
-  // entropy 1 bit, so information content is 2 - 1 = 1, split evenly
-  expect(stack[0]!.bits).toBeCloseTo(0.5, 10)
-  expect(stack[1]!.bits).toBeCloseTo(0.5, 10)
-})
-
-test('letters are ordered ascending so the tallest draws last, on top', () => {
-  const stack = stackOf('AAAC')
-  expect(stack.map(s => s.letter)).toEqual(['C', 'A'])
-  expect(stack[0]!.bits).toBeLessThan(stack[1]!.bits)
-})
-
-test('ties break on letter so redraws are stable', () => {
-  expect(stackOf('GGCC').map(s => s.letter)).toEqual(['C', 'G'])
-  expect(stackOf('CCGG').map(s => s.letter)).toEqual(['C', 'G'])
-})
-
-test('gaps scale the stack down without skewing the frequencies', () => {
-  // 'A' is the only residue, so it takes the whole stack either way; the height
-  // is what the gaps change
-  const clean = stackOf('AAAA')
-  const gappy = stackOf('AA--')
-  expect(gappy[0]!.letter).toBe('A')
-  expect(gappy[0]!.bits).toBeCloseTo(clean[0]!.bits / 2, 10)
-})
-
-test('gaps do not make a two-residue column look like a four-way one', () => {
-  // frequencies come from the two real residues, so this is a 1-bit choice
-  // scaled by the half-gap occupancy, not a 4-way split
-  const stack = stackOf('AC--')
-  expect(stack.map(s => s.letter)).toEqual(['A', 'C'])
-  expect(stack[0]!.bits + stack[1]!.bits).toBeCloseTo(0.5, 10)
-})
-
-test('an all-gap column has no stack', () => {
-  expect(stackOf('----')).toEqual([])
-  expect(stackOf('....')).toEqual([])
-})
-
-test('the protein ceiling is higher than the nucleotide one', () => {
-  const protein = stackOf('WWWW', aminoBits)
-  expect(protein[0]!.bits).toBeCloseTo(aminoBits, 10)
-  expect(protein[0]!.bits).toBeGreaterThan(stackOf('AAAA')[0]!.bits)
-})
-
-test('stack height never exceeds the ceiling', () => {
-  const columns = ['AAAA', 'AACG', 'A-C-', 'ACGT', 'AAAT']
-  for (const column of columns) {
-    const total = stackOf(column).reduce((a, b) => a + b.bits, 0)
-    expect(total).toBeLessThanOrEqual(dnaBits + 1e-9)
-  }
-})
-
-test('a column past the end of a ragged alignment is empty, not a crash', () => {
-  const counts = columnCountsFromColumns(['AC'])
-  expect(columnLogoStack(counts, 5, dnaBits)).toEqual([])
-})

package/src/setFontSize.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { setFontSize } from './setFontSize.ts'
-
-describe('setFontSize', () => {
-  test('replaces integer size, preserving family', () => {
-    const ctx = { font: '10px sans-serif' }
-    setFontSize(ctx, 16)
-    expect(ctx.font).toBe('16px sans-serif')
-  })
-
-  test('handles fractional sizes from smooth zoom', () => {
-    // regression: \d+ alone matched "8604" inside "14.8604px" and produced an
-    // invalid string like "14 0.18px sans-serif", silently breaking fillText
-    const ctx = { font: '14.8604px sans-serif' }
-    setFontSize(ctx, 16.9372)
-    expect(ctx.font).toBe('16.9372px sans-serif')
-  })
-
-  test('does not accumulate "bold " across re-renders', () => {
-    const ctx = { font: '10px sans-serif' }
-    setFontSize(ctx, 12, true)
-    expect(ctx.font).toBe('bold 12px sans-serif')
-    setFontSize(ctx, 14, true)
-    expect(ctx.font).toBe('bold 14px sans-serif')
-  })
-
-  test('drops "bold " when bold goes false', () => {
-    const ctx = { font: 'bold 12px sans-serif' }
-    setFontSize(ctx, 14)
-    expect(ctx.font).toBe('14px sans-serif')
-  })
-})

package/src/stripDefault.test.ts

@@ -1,48 +0,0 @@
-import { getSnapshot, types } from '@jbrowse/mobx-state-tree'
-import { afterEach, expect, test } from 'vitest'
-
-import { stripDefault } from './stripDefault.ts'
-
-const real = types.stripDefault
-
-afterEach(() => {
-  types.stripDefault = real
-})
-
-test('strips defaults from the snapshot when the host mst supports it', () => {
-  const model = types
-    .model({ a: stripDefault(types.boolean, false) })
-    .create({})
-  expect(model.a).toBe(false)
-  expect(getSnapshot(model).a).toBeUndefined()
-})
-
-// The path that actually runs inside every RELEASED jbrowse-web: the host
-// supplies its own mobx-state-tree, and stripDefault only exists in the copy
-// that ships with unreleased @jbrowse/core. Calling it there used to throw while
-// the model was built, which error-paged the whole app. dev has the API, so
-// without stubbing it away this path is never exercised.
-test('falls back to types.optional when the host mst lacks stripDefault', () => {
-  // @ts-expect-error deleting it is the point: simulate an older host
-  delete types.stripDefault
-  const model = types
-    .model({ a: stripDefault(types.boolean, false) })
-    .create({})
-  expect(model.a).toBe(false)
-  // the only difference: the default is serialized rather than omitted
-  expect(getSnapshot(model).a).toBe(false)
-})
-
-test('non-default values survive both paths', () => {
-  const withApi = types
-    .model({ a: stripDefault(types.number, 1) })
-    .create({ a: 5 })
-  expect(getSnapshot(withApi).a).toBe(5)
-
-  // @ts-expect-error see above
-  delete types.stripDefault
-  const without = types
-    .model({ a: stripDefault(types.number, 1) })
-    .create({ a: 5 })
-  expect(getSnapshot(without).a).toBe(5)
-})