react-msaview 6.5.0 → 7.0.0

package/src/renderRasterSvg.test.tsx

@@ -1,144 +0,0 @@
-// @vitest-environment jsdom
-//
-// The SVG export's raster background. jsdom has no canvas, so the export falls
-// back to a <rect> per cell there and every other export test exercises that
-// path; this file supplies the canvas the raster needs and checks the export
-// takes it instead.
-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'
-
-const dataUrl = 'data:image/png;base64,STUB'
-
-// enough of a 2d context for the raster: a color parser, an ImageData that is
-// really backed by bytes, and a canvas that reads back
-beforeAll(() => {
-  installSvgTestEnv({
-    fillStyle: '#000000',
-    clearRect: () => {},
-    fillRect: () => {},
-    createImageData: ((width: number, height: number) => ({
-      data: new Uint8ClampedArray(width * height * 4),
-      width,
-      height,
-    })) as unknown as CanvasRenderingContext2D['createImageData'],
-    putImageData: () => {},
-    getImageData: (() => ({
-      data: Uint8ClampedArray.from([1, 2, 3, 255]),
-    })) as unknown as CanvasRenderingContext2D['getImageData'],
-  })
-  HTMLCanvasElement.prototype.toDataURL = () => dataUrl
-})
-
-function makeModel(rows: number, cols: number) {
-  return createTestModel({
-    id: 'raster',
-    data: { msa: syntheticProteinMsa(rows, cols) },
-  })
-}
-
-function exportEntire(model: ReturnType<typeof makeModel>) {
-  return renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'entire',
-  })
-}
-
-test('the background is one image, not a rect per cell', async () => {
-  const model = makeModel(40, 300)
-  expect(model.bgColor).toBe(true)
-  expect(model.actuallyShowDomains).toBe(false)
-
-  const svg = await exportEntire(model)
-  const images = [...svg.matchAll(/<image[^>]*>/g)].map(m => m[0])
-
-  expect(images).toHaveLength(1)
-  expect(images[0]).toContain(dataUrl)
-  // the alignment's own rectangle, one pixel per cell scaled up by whole cells
-  expect(images[0]).toContain(`width="${300 * model.colWidth}"`)
-  expect(images[0]).toContain(`height="${40 * model.rowHeight}"`)
-  expect(images[0]).toContain('image-rendering="pixelated"')
-
-  // 12000 cells would have been 12000 rects
-  expect((svg.match(/<rect/g) ?? []).length).toBeLessThan(10)
-})
-
-test('letters still draw on top of the raster', async () => {
-  const model = makeModel(4, 10)
-  expect(model.showMsaLetters).toBe(true)
-
-  const svg = await exportEntire(model)
-
-  expect(svg).toContain('<image')
-  expect((svg.match(/<text/g) ?? []).length).toBeGreaterThanOrEqual(40)
-})
-
-test('the domain overlay keeps the vector path, which paints its own boxes', async () => {
-  const model = makeModel(4, 10)
-  model.setDomains({
-    seq0: {
-      xref: [{ id: 'seq0' }],
-      matches: [
-        {
-          signature: {
-            entry: { name: 'Kinase', accession: 'PF00069', description: '' },
-          },
-          locations: [{ start: 1, end: 5 }],
-        },
-      ],
-    },
-  })
-  expect(model.actuallyShowDomains).toBe(true)
-
-  expect(await exportEntire(model)).not.toContain('<image')
-})
-
-test('turning background color off leaves nothing for a raster to draw', async () => {
-  const model = makeModel(4, 10)
-  model.setBgColor(false)
-
-  expect(await exportEntire(model)).not.toContain('<image')
-})
-
-test('the exported minimap carries the alignment thumbnail', async () => {
-  const model = makeModel(20, 2000)
-  expect(model.showHorizontalScrollbar).toBe(true)
-
-  const svg = await renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'viewport',
-    includeMinimap: true,
-  })
-
-  // the bar is the same downsampled alignment the live minimap draws, rather
-  // than the empty outline the export used to leave
-  const bar = [...svg.matchAll(/<image[^>]*>/g)]
-    .map(m => m[0])
-    .find(i => i.includes('height="12"'))
-  expect(bar).toBeDefined()
-  expect(bar).toContain(dataUrl)
-  expect(bar).toContain(`width="${model.msaCanvasWidth}"`)
-})
-
-test('each track is named in the tree column beside it', async () => {
-  const model = makeModel(4, 40)
-  model.toggleTrack('sequence-logo')
-  const names = model.turnedOnTracks.map(t => t.model.name)
-  expect(names.length).toBeGreaterThan(1)
-
-  const svg = await renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'entire',
-    includeTracks: true,
-  })
-
-  for (const name of names) {
-    expect(svg).toContain(`>${name}</text>`)
-  }
-})

package/src/renderSequenceLogoSvg.test.tsx

@@ -1,165 +0,0 @@
-// @vitest-environment jsdom
-//
-// The logo track is the first track kind whose letters are drawn under a
-// per-letter transform rather than at a fixed size, so it is also the first that
-// can silently draw nothing if the export context loses that transform. These
-// tests go through the real SVG export to pin the whole path: the track is off
-// until asked for, the stack is ordered and scaled, and the glyphs land inside
-// the track's own band.
-import { createJBrowseTheme } from '@jbrowse/core/ui/theme'
-import { beforeAll, expect, test } from 'vitest'
-
-import { CHAR_WIDTH_RATIO } from './headlessRenderEnv.ts'
-import { renderToSvg } from './renderToSvg.tsx'
-import { createTestModel, installSvgTestEnv } from './svgTestUtil.ts'
-
-beforeAll(() => {
-  installSvgTestEnv()
-})
-
-// column 0 is fully conserved A, column 1 is a 3:1 split of C over G, and
-// column 2 is an even four-way split carrying no information at all
-const msa = `>s1\nACA\n>s2\nACC\n>s3\nACG\n>s4\nAGT\n`
-const colWidth = 40
-
-function makeModel() {
-  return createTestModel({ colWidth, data: { msa } }, 1000)
-}
-
-async function exportSvg(model: ReturnType<typeof makeModel>) {
-  return renderToSvg(model, {
-    theme: createJBrowseTheme(),
-    exportType: 'entire',
-    includeTracks: true,
-  })
-}
-
-// The logo's glyphs are the only <text> drawn at the track's own font size, and
-// the only ones carrying a non-unit vertical scale, which is what separates them
-// from the alignment letters and tree labels in the same document.
-function logoGlyphs(svg: string, fontSize: number) {
-  return [
-    ...svg.matchAll(
-      /<text[^>]*font-size="([\d.]+)px"[^>]*transform="matrix\(([^)]*)\)"[^>]*>([A-Z])<\/text>/g,
-    ),
-  ]
-    .filter(m => Number(m[1]) === fontSize)
-    .map(m => {
-      const [sx, , , sy, tx, ty] = m[2]!.split(/[\s,]+/).map(Number)
-      return { letter: m[3]!, sx: sx!, sy: sy!, x: tx!, y: ty! }
-    })
-}
-
-async function glyphsOf(model: ReturnType<typeof makeModel>) {
-  return logoGlyphs(await exportSvg(model), model.sequenceLogoTrackHeight)
-}
-
-test('the logo track is hidden until it is asked for', () => {
-  const model = makeModel()
-  expect(model.tracks.map(t => t.model.id)).toContain('sequence-logo')
-  expect(model.turnedOnTracks.map(t => t.model.id)).not.toContain(
-    'sequence-logo',
-  )
-  // and being default-off writes nothing into the shareable snapshot
-  expect(model.turnedOffTracks.size).toBe(0)
-})
-
-test('toggling it on shows it, and off again hides it', () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-  expect(model.turnedOnTracks.map(t => t.model.id)).toContain('sequence-logo')
-  model.toggleTrack('sequence-logo')
-  expect(model.turnedOnTracks.map(t => t.model.id)).not.toContain(
-    'sequence-logo',
-  )
-})
-
-test('an on-by-default track still toggles off and back on', () => {
-  const model = makeModel()
-  expect(model.turnedOnTracks.map(t => t.model.id)).toContain('conservation')
-  model.toggleTrack('conservation')
-  expect(model.turnedOnTracks.map(t => t.model.id)).not.toContain(
-    'conservation',
-  )
-  model.toggleTrack('conservation')
-  expect(model.turnedOnTracks.map(t => t.model.id)).toContain('conservation')
-})
-
-test('the conserved column draws one full-height letter', async () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-  const col0 = (await glyphsOf(model)).filter(g => g.x === 0)
-
-  expect(col0.map(g => g.letter)).toEqual(['A'])
-  // a fully conserved nucleotide column is 2 of 2 bits, so the glyph stretches
-  // to the whole track height over the cap height of the reference font
-  expect(col0[0]!.sy).toBeCloseTo(1 / 0.72, 5)
-})
-
-test('a split column stacks the minor letter below the major one', async () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-  const col1 = (await glyphsOf(model)).filter(g => g.x === colWidth)
-
-  // ascending order means C (3 of 4) is drawn last, so it ends up on top
-  expect(col1.map(g => g.letter)).toEqual(['G', 'C'])
-  const [g, c] = col1
-  expect(c!.sy).toBeGreaterThan(g!.sy)
-  // and the taller letter sits higher up the track (smaller y is nearer the top)
-  expect(c!.y).toBeLessThan(g!.y)
-})
-
-test('the uninformative column draws nothing', async () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-  const glyphs = await glyphsOf(model)
-  expect(glyphs.filter(g => g.x === colWidth * 2)).toEqual([])
-  // the other two columns did draw, so an empty column 2 is the logo's own
-  // verdict rather than the whole track missing
-  expect(glyphs).toHaveLength(3)
-})
-
-test('every glyph stays inside the track band', async () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-
-  // the export stacks the tracks, so the logo's band is offset by whatever is
-  // drawn above it -- assert against that band rather than against 0..height,
-  // which would pass only while the logo happened to be the first track
-  const above = model.turnedOnTracks
-    .slice(
-      0,
-      model.turnedOnTracks.findIndex(t => t.model.id === 'sequence-logo'),
-    )
-    .reduce((a, t) => a + t.model.height, 0)
-  const bandTop = above
-  const bandBottom = above + model.sequenceLogoTrackHeight
-
-  const glyphs = await glyphsOf(model)
-  expect(glyphs.length).toBeGreaterThan(0)
-  for (const glyph of glyphs) {
-    // baselines run from the band's bottom edge upward, never past either end
-    expect(glyph.y).toBeGreaterThan(bandTop)
-    expect(glyph.y).toBeLessThanOrEqual(bandBottom)
-  }
-})
-
-test('letters are stretched to fill their column', async () => {
-  const model = makeModel()
-  model.toggleTrack('sequence-logo')
-  const glyphs = await glyphsOf(model)
-
-  const expected = colWidth / (model.sequenceLogoTrackHeight * CHAR_WIDTH_RATIO)
-  for (const glyph of glyphs) {
-    expect(glyph.sx).toBeCloseTo(expected, 5)
-  }
-})
-
-test('the logo appears in the export only when the track is on', async () => {
-  const off = makeModel()
-  expect(await glyphsOf(off)).toEqual([])
-
-  const on = makeModel()
-  on.toggleTrack('sequence-logo')
-  expect((await glyphsOf(on)).length).toBeGreaterThan(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)
-})