LinearMultiSampleVariantDisplay

Auto-generated from the @jbrowse/mobx-state-tree model in the source — see the developer guide for concepts. Provided by the variants plugin. View source.

Example usage

unit, rowColor, rows and minorAlleleFrequencyFilter are config (see the display's config schema), read at runtime through getConf and written as session edits to the track's config — they are NOT plain MST properties. Set them in a track's displays array to change the default:

displays: [
  {
    type: 'LinearMultiSampleVariantDisplay',
    displayId: 'my-cohort',
    unit: 'haplotype',
    rowColor: 'population',
    rows: { domain: ['NA12878', 'NA12891'] },
  },
]

runClustering is a transient declarative launch spec, the same idea as LinearGenomeView's init: set it to run the real "Cluster rows by genotype" RPC once automatically (no dialog) as soon as sources are available, and it clears itself afterwards so a saved session never re-triggers it.

displays: [
  {
    type: 'LinearMultiSampleVariantDisplay',
    runClustering: true,
  },
]

How the rows are arranged

The arrangement is config: rows holds the order, the labels, the cluster tree with its provenance and the focus, and rowColor the colors, each by row name at the mode's granularity — a sample in allele-count mode, a haplotype ("<sample> HP<n>") in phased mode, where a sample name stands for its haplotypes. A drag, the arrangement dialog, "Sort rows by genotype here" and a clustering run write it; the rows are derived from it on every read:

the adapter's samples (adapterSamples) are focused by rows.kept, which is the set the fetch asks for (sourcesBase, sampleFilter),
phased mode expands each sample to its haplotypes (expandedRows), and rows.domain orders, rows.labels relabels and each row carries its resolved rowColor (editableSources, the dialog's list), each from TreeSidebarMixin over this display's hooks,
the focus narrows those (clusterableSources, what a run clusters),
facet stacks those in bands (bandedSources), each band's rows in their arranged order,
the result is sources, each row's rowColor its label bar.

The rowColor palette wins over a color the row already carried, a samplesTsv color column: a channel bound to a variable beats a per-row constant, so "Color by… → (none)" is what hands the row back its own color. rowColor holds one field's values, so a dialog color set under the palette turns every row's color into a name pair.

The facet bands win over a tree: a band draws the clade of the tree whose leaves are exactly its rows in order, and a clustering run under bands clusters each band apart and writes one forest. A whole-cohort tree under a facet set afterwards draws where a band happens to be a clade, and the hint counts the bands without one.

Multi-sample variant display drawing one genotype row per sample, with a per-cell feature widget on click.

The configuration slots for this model are documented on its config schema page.

Each section ends with the members a composed model contributes, linked to the page that documents them.

Properties

Member	Description
type `type: types.literal(MULTI_SAMPLE_VARIANT_DISPLAY)`
configuration `configuration: ConfigurationReference(configSchema)`

4 inherited properties from 2 models

From BaseDisplay: id

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

Volatiles

Member	Description
sampleListing `AdapterRead<Source[]> \| undefined`	The adapter's sample list, stamped with the adapter config it answers.
cellData `CellDataResult \| undefined`	The fetched per-display data, replaced whole by each fetch.
cellDataRegionIndices `ReadonlySet<number>`	The displayed regions the current `cellData` was fetched for. The payload itself cannot say: a region with no variants gets no `perRegionCellData` entry, and the columns payload is one entry for every region.
cellDataBpPerPx `number \| undefined`	The zoom the current `cellData` was fetched at, set in columns alone. The columns are the features of exactly the span on screen, so after a zoom inside the loaded span the held payload still lays out features the view no longer shows. Undefined answers at every zoom, as the position-drawn payload does.
hoveredCell `HoveredCell \| undefined`	The genotype cell under the pointer, as `hoverInk` lights it; the shared tooltip slot has no reason to carry the cell's instance.
hoveredLaneMark `HitFeatureResult \| undefined`	The lane mark under the pointer — plugin-canvas's own hit, so `hoverInk` lands on the box the lane painted.
hoveredMatrixCell `MatrixHoveredCell \| undefined`	The matrix cell under the pointer, in the equal-width column layout.
backendDrawsColumns `boolean`	Whether the attached backend draws columns, so the upload sends it the payload it can draw across the swap a layout change makes.

28 inherited volatiles from 10 models

From BaseDisplay: error, statusMessage, statusProgress

From TrackHeightMixin: scrollTop, hostHeight

From MultiRegionDisplayMixin: loadedRegions

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From RenderLifecycleMixin: canvasDrawn, paintCount, currentRenderingBackend, renderTick, autorunsInstalled, renderError, offScreen

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, fetchCanceled, fetchRotation

From LegendMixin: dismissedLegendSections

From StoredHoverMixin: storedHoveredFeature

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

From ContextMenuMixin: contextMenuInfo

Getters

Member	Description
adapterSamples `Source[] \| undefined`	The samples the adapter lists, undefined until the current adapter config's list lands.
view ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & { rubberbandClickMenuItems(clickOffset: BpOffset): MenuItem[]; highlightMenuItems(_highlight: HighlightType): MenuItem[]; } & { flyTo: (centerBp: number, windowWidthBp: number) => void; flyToCenter(coord: number, refName: string, displayedRegionIndex?: number \| undefined): void; flyToFit(centerBp: number, fitWidthBp: number): void; } & { afterCreate(): void; afterAttach(): void; } & IStateTreeNode<…>
hasPhasedOrHaploid `boolean`	Whether any called genotype is phased or haploid (no `/`), which gates the per-haplotype rows; a pangenome callset writes bare `0`/`1` with no `\|` anywhere.
hasSecondaryAlt `boolean`	Whether the worker painted a secondary-alt cell, which keys the "Other alt allele" legend entry. Painted, not possible.
hasAltWithoutPhaseSet `boolean`	Whether phase-set coloring painted an alt cell whose call names no phase set, which keys that cell's plain hue.
hasUnphased `boolean`	Whether the worker painted a black unphased cell (drives the "Unphased" legend entry).
hasNoCall `boolean`	Whether the worker painted a no-call cell (drives the "No call" legend entry).
hasConsequence `boolean`	Whether any visible variant carries a SnpEff/VEP annotation, gating the "Color by...→Consequence impact" menu option.
hasSvType `boolean`	Whether any visible variant is a structural variant, gating the "Color by...→SV type" menu option.
hasPhaseSet `boolean`	Whether any visible variant declares a phase set (PS in FORMAT), gating the "Color by...→Phase set" menu option.
samplePloidy `Readonly<Record<string, number>> \| undefined`	Each sample's ploidy as the latest fetch reports it, the same object while a region arrival reports the same ploidies, so the phased rows are expanded again only when one changes.
unit `"haplotype" \| "sample"`
showInsertionGlyphs `boolean`	Whether an insertion draws as a marker sized by its inserted bp, or at the 2px floor like a SNP. The marker overlay, the hover highlight and the click target all read it through `variantCellSpanPx`, so the three agree.
variantLayout `"columns" \| "genomic"`	Whether each variant draws at its genomic span, or as one of a row of equal-width columns tied to its position by a connector line.
atGenomicPositions `boolean`
lineZoneHeight `number`	Height of the connector-line zone above the columns; 0 at genomic positions, where nothing needs connecting.
showVariantLane `boolean`	Whether the variant lane, a strip of the records themselves above the genotype rows, is drawn: at genomic positions only, where it lines up with the cells under it.
variantLaneHeight `number`	Configured height of the variant lane. Raw: what the band spends is `topBands.laneHeight`.
variantLaneLabels `"auto" \| "description" \| "name" \| "nameAndDescription" \| "none"`	Which label kinds the variant lane asks for; what it draws is `laneRenderedLabels`.
showRowSeparators `boolean`
showTooltips `boolean`	Whether a hover draws the tooltip table. The crosshairs, the hovered-cell highlight and `hoveredFeature` keep working with it off.
facet `FacetSetting \| undefined`	The `facet` object as written: the sample-metadata attribute whose values band the rows, and the band order; undefined leaves the existing order alone.
colorSetting `ColorSetting`	The `color` object as written, `value` raw: a `jexl:` callback is the worker's to evaluate per variant.
notices `string[]`	What the `color` object's slots say together that it cannot paint as written, and `rowBandingNotices`, for the corner notice.
colorEncoding `string \| FieldColorEncoding \| undefined`	What the alt cells' hue paints: undefined for the genotype colors, a CSS color or `jexl:` callback, or a field through its categorical or threshold scale (`shared/cellHue.ts`).
colorField `string`	The field the alt cells paint by, '' while they paint the genotype colors or a constant.
shadeByDosage `boolean`	Whether an alt cell's hue is composed with the genotype's alt dosage. The main thread paints it, so a toggle refetches nothing.
featureWidgetType `{ type: string; id: string; }`
minorAlleleFrequencyFilter `number`
maxMissingnessFilter `number`	Max fraction of no-call genotypes a variant may have before it's hidden; 1 keeps every variant
filters `SerializableFilterChain \| undefined`	The jexl filter expressions as the RPC's `filters` arg.
referenceDrawingMode `string`
colorByAttributes `string[]`	Distinct sample-metadata attributes (from samplesTsv) the user can color rows by — every key the sources carry except internal plumbing.
rowColorPaintsMarks `boolean`	`TreeSidebarMixin`'s hook: never, since the cells paint by genotype and a row's color shows only on its label bar.
internalRowFields `readonly string[]`	`TreeSidebarMixin`'s hook: a haplotype row's `sampleName` and `HP`, which the arrangement dialog lists as no column.
rowColorFields `readonly string[]`	`TreeSidebarMixin`'s hook: the samplesTsv attributes, the ones "Color by..." offers.
discoveredRows `ProcessedSource[]`	`TreeSidebarMixin`'s hook: the adapter's samples as rows, each answering to its sample name, a samplesTsv `color` column the row's own color.
rowAlias `RowAlias`	`TreeSidebarMixin`'s hook: a haplotype row answers to its sample's name, so an order, a label, a tint or a focus written against a sample reaches each of its haplotypes.
rowBanding `RowBanding \| undefined`	`TreeSidebarMixin`'s hook: the `facet` bands the rows by a samplesTsv attribute.
sourcesBase `Source[] \| undefined`	The adapter's samples narrowed to the focus, `rows.kept`: the row set the fetch asks for, so it must not read `samplePloidy`. `undefined` until the samples land, a transition that wakes the fetch autorun (reference/FETCH_KEYS.md).
clusteringReady `boolean`	Whether the rows are at the granularity they draw, which clustering and the arrangement dialog need: phased mode draws haplotypes, which needs the `samplePloidy` a fetch brings.
hasClusterableRows `boolean`	Whether there are at least two rows on screen to put in an order, counted over `clusterableSources`, the list a run clusters.
autoClusterReady `boolean`	Whether the declarative `runClustering: true` path may fire.
sampleFilter `string[] \| undefined`	Which samples the worker emits rows for, as a sorted set: row order is not a fetch input (reference/FETCH_KEYS.md). `undefined` means the sources haven't loaded and is never reused for "all of them", or the fetch would not wake when they land. Reads `sourcesBase`, never `sources`, which reads the fetch-derived `samplePloidy`.
cellHue `CellHue`	Where the alt cells' hue comes from: what the worker reads and how the main thread paints it (`cellHueOf`).
cellHueValuesRead `boolean`	Whether the held payload's color values were read for the current `color`; one read for another paints as though it read none.
paintedDomain `string[]`	The cell scale's domain values an alt cell was painted for in the fetched cell data — the impact tiers or SV classes the legend lists.
sourceMap `Map<string, ProcessedSource>`	Row name -> source, for the hover tooltip. A Map because row names come from the file, and on a plain object a sample called `constructor` resolves to something inherited rather than to a miss.
genotypeSampleIndex `Map<string, number> \| undefined`	sampleName -> column of each feature's interned `genotypeCodes`, for the tooltips (genotypeCodec.ts). Rebuilt per pointer frame, its readers being untracked pointer handlers. A keep-alive autorun was tried and throws on test stubs that resolve the cell-data RPC to a bare `[]`.
rowRemap `Uint32Array<ArrayBufferLike> \| undefined`	Worker row -> screen row. The cells arrive numbered against the worker's `rowNames`, so rebuilding this is all a reorder costs, and a change that moves no row hands back the previous array. A worker row the display isn't drawing maps to `HIDDEN_ROW`, which every painter's Y-cull puts below the canvas. Undefined until data lands: never fall back to identity, the worker's order is its own.
topBands `VariantTopBands`	The bands stacked above the rows — the variant lane and the connector-line zone — resolved once. Both the layout below and the painters read this, never their own sum: see `variantTopBands.ts`.
rowsHeaderHeight `number`	`TreeSidebarMixin`'s hook: the variant lane and the connector-line zone, which `rowsTopOffset` stacks the focus chip's line under.
availableHeight `number`	Height left for the rows under the bands above them, floored at 0: every consumer treats it as a pixel dimension.
nrow `number`
autoRowHeight `number`	What fit-to-display-height divides between the rows.
svgSidebar `SvgSidebarProps`
rowUnmap `Int32Array<ArrayBufferLike> \| undefined`	Screen row -> worker row, `-1` for a screen row the data has no cells for. The cell arrays stay in the worker's numbering, which `findCellIndex` binary-searches, so the hit test converts its row.
hoveredTooltipSource `VariantHoverFields \| undefined`	The hovered thing as the tooltip table reads it: the record's fields over the hovered row's sample metadata. A lane hover names no row and is the record's fields alone. Undefined with `showTooltips` off.
matrixWidth `number`	The width the columns are laid out in: the rounded content width, so they still fill the drawn matrix when the genome doesn't reach across the viewport. Not `canvasWidthPx`, the viewport box a span maps bp into — the LD display's triangle takes the same width for the same reason.
renderState `{ canvasWidth: number; canvasHeight: number; rowHeight: number; scrollTop: number; }`
scrollContentHeight `number`
scrollViewportHeight `number`
gateEnabled `boolean`	Opt into RegionTooLargeMixin's byte gate.
prefersOffset `boolean`	Both layouts fill the track with rows, so an overlapping track label would sit on top of a sample's genotypes.
awaitingPrerequisite `boolean`	`fetchNeeded` declines until `sourcesBase` lands, so the retry contract is judged on the run that follows (`FetchMixin.awaitingPrerequisite`).
cellPaintOptions `{ phased: boolean; shade: boolean; valuesRead: boolean; }`	How the held payload's alt cells paint (`paintCellColors`).
regionRecordAlpha `Map<number, Float32Array<ArrayBufferLike> \| undefined>`	Each fetched region's records' alpha factors where they share pixels at genomic positions (`recordDensityAlpha`), so a zoomed-out row shades by the share of its records that are alt instead of filling wherever any is
regionCellColors `Map<number, Uint32Array<ArrayBufferLike>>`	Each fetched region's cell colors through the current `color`, faded where records share pixels. Apart from the rows, so a reorder repaints nothing, and a recolor re-places nothing and refetches nothing.
regionFeatureColors `Map<number, Uint32Array<ArrayBufferLike>>`	Each fetched region's lane colors, which neither shading nor the phased mode moves.
placedRegionRows `Map<number, Placed<VariantCellData>>`	Each fetched region with its rows placed on screen. A computed apart from the colors, so a recolor leaves it standing.
regionCellGlyphs `Map<number, CellGlyphs>`	Each fetched region's cells as the `cell` mark's own attributes: the record's span and glyph, which the payload carries once per record, dealt to each of its cells. Off `cellData` alone, since neither a reorder nor a recolor moves a cell's span.
paintedRegionRows `Map<number, Placed<VariantCellData>>`	Each fetched region placed (`placedRegionRows`) and painted (`regionCellColors`), the cells both layouts draw. A reorder or a recolor changes an entry's identity and `installUpload` re-uploads with no RPC. A computed, because the overlay draws in an effect where nothing is tracked.
perRegionCellMap `Map<number, VariantCellData & { cellWorkerRowIndices: Uint32Array<ArrayBufferLike>; } & CellGlyphs & { insertions?: InsertionChannels \| undefined; }>`	The one walk of the payload every genomic-position consumer reads: `paintedRegionRows` with the `cell` mark's attributes and, while `showInsertionGlyphs` is on, the insertion markers' channels.
columnGeometry `{ n: number; columnWidth: number; left: number; }`	Column pitch and origin in viewport pixels: `left` is where the content starts when it doesn't reach the left viewport edge. The connector lines, their hit test and the crosshair column all key off this, so columns, lines and clicks stay pixel-aligned.
matrixBlocks `RenderBlock[]`	The one block the column layout draws: the whole canvas, spanning the column indices. One column wide when there are none, since the GPU backend skips a block with no span and the canvas would never count as painted.
connectorCoordsByColumn `(ConnectorCoord \| undefined)[]`	One connector per column, by column, in viewport pixels: `mx` the column centre, `gx` the variant's position on the ruler, `label` what the hover tooltip shows. `undefined` where the variant's refName has left the view. Indexed rather than filtered, so the crosshair can ask of one column what the drawn field asks of all. Column and data index are one number: the worker ships the variants in screen order.
connectorLineCoords `ConnectorCoord[]`	The connector lines that draw: those with a genomic x.
hoverInk `HighlightRect[]`	The box of the hovered genotype cell or lane mark, for the chrome's highlight. A cell is its instance through the cell mark's ink, moved down by the bands above the rows, and widened to the insertion marker where one paints over it; a lane mark is the box plugin-canvas laid out and painted, in the lane at the top.
highlightStyle `HighlightStyle`	A wash and a border: the cell colors are the data.
insertionGlyphRegions `Map<number, VariantCellData & { cellWorkerRowIndices: Uint32Array<ArrayBufferLike>; } & CellGlyphs & { insertions?: InsertionChannels \| undefined; }> \| undefined`	Per-region cell data for the insertion counts' overlay, or undefined when no marker can draw in this window, which unmounts the overlay rather than repainting it empty on every pan frame.
drawsInsertionMarkers `boolean`	Whether insertion markers draw in the current window, which keys the marker in the legend. Asked of the painter's own blocks (`anyMarkerPossibleForBlock`): "the window holds an insertion" keys a callset of short indels that never draws one.
featureIndices `Map<number, Flatbush>`	Per-region spatial index over feature intervals, for the hit-test. One entry per variant, not per cell — see computeVariantCells.
laneDisplayConfig `DisplayConfig`	The plugin-canvas display config the lane's band is laid out with. See `laneDisplayConfig` — a literal, because a band has no config schema.
laneFontSize `number`	The label size the lane's marks are lettered at — plugin-canvas's, for the lane's display mode, so the width its packer reserved is the width the text draws at.
laneRenderDataMap `ReadonlyMap<number, LayoutRegionData>`	The lane's marks as plugin-canvas render data, one entry per fetched region, empty while the band is off. Keyed off the fetched payload and the displayed regions' bounds, never the row-placed map or `visibleRegions`, which would rebuild it per reorder or per frame.
laneLayoutInputs `Omit<LayoutInputs, "showDescriptions" \| "showLabels">`	What the lane's packer reads, minus the label reservation each fit rung varies. `coarseBpPerPx`, so packing does not recompute per frame of a zoom.
laneDecimatedInputs `LabelRoomFactorFreeInputs`	Inputs for the `decimated` rung, whose whitespace factor is solved against the band height. Descriptions are already gone by that rung.
laneFitStage `FitStage`	The rung the lane keeps and the scale that fills the band with it: plugin-canvas's fit ladder, run against `laneHeight`.
laneLaidOutDataMap `ReadonlyMap<number, FeatureDataResult>`	What the lane's painter, its labels and its hit test all read: the resolved stack, scaled only when the fit grew or squeezed it.
laneContentHeight `number`	The band's drawn height: the kept rung's stack, scaled, at most `laneHeight`.
laneRenderedLabels `{ showLabels: boolean; showDescriptions: boolean; }`	Which label kinds the lane actually paints: what the kept rung reserved, so a box never reserves width for a description the band had no room to draw.
laneFlatbushIndexes `Map<number, FlatbushRegionIndexes>`	Per-region hit index over the lane's laid-out marks, off the stack that was painted and the RENDERED label flags, a label's overhang being part of its hit box. Its dependencies are debounced, so the `LaneHitIndexes` autorun holds it alive across pointer frames.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the cell coloring, the insertion marker where one is drawn, and the row color key. Whether the marker is keyed is `drawsInsertionMarkers`' answer, the painter's own test on the painter's own blocks.

123 inherited getters from 10 models

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, hoveredFeature, featureNoun, plotKeys, plot, plotExamples, configDocsUrl

From TrackHeightMixin: configuredHeight, allottedHeight, height, resizing, scrollableHeight

From MultiRegionDisplayMixin: host, canvasWidthPx, settledSubPixelBinBp, canRender, rendersCanvas, trackVisibleRegions, viewportWithinLoadedData, viewportEmpty, fetchSuspended, layoutReady, dataSuperseded, renderBlocks, fetchInputs, regionPayloads, hasRegionData, staleSettingsDrawn, dataCurrent, loadedAssembly, phaseViewportCurrent, svgReady, paintInert, paintSuperseded, displayPhase

From RegionTooLargeMixin: byteGateAdapterConfig, configuredFetchSizeLimit, densityTooLarge, byteGateAdapterPath, adapterFetchSizeLimit, configForceLoad, gateViewportSpanBp, gateViewport, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateMeasurementStale, gateByteLimit, gateActive, densityGateActive, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport

From RenderLifecycleMixin: painted

From FetchMixin: isLoading, isLoadingOrCanceled, fetchInert, awaitingDependentData, settingsFetchInputs

From LegendMixin: showLegend, legendTop, legendRight, legendSpec, hasLegendKey

From ColorWritesMixin: writtenColor

From RowHeightMixin: rowHeight, effectiveRowHeight

From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowDomain, rowLabels, rowTreeProvenance, rowFocus, rowColorSetting, baseRowColor, baseRowDomain, guideTreeNewick, unlistedRowsSort, rowFocusLineHeight, rowsTopOffset, guideTree, guideTreeHonoursDomain, rowTree, rowOrder, expandedRows, sharesPanel, rowNoun, rowBandingNotices, rowPaletteDeals, rowColorDealRows, rowStylingIsCustom, rowColorChoice, rowColorAttribute, dealtRowColors, rowColorAttributesOffered, resolvedRowColors, rowArrangementIsCustom, editableSources, rowColorKeyInputs, rowColorScales, clusterableSources, parsedTree, root, bandedRows, bandedSources, rowBands, sources, treeRoot, drawsTree, rowsContentHeight, hierarchy, spatialIndex, clusterPartition, treelessBandCount, treeHasBranchLengths

Methods

Member	Description
featureInfoById `(featureId: string) => VariantFeatureInfo \| undefined`	The payload's record behind a cell or a lane mark.
simplifiedFeatureById `(featureId: string) => SimplifiedVariantFeature \| undefined`	The payload's positional record behind a cell or a lane mark.
regionHasData `(displayedRegionIndex: number) => boolean`	Whether the held payload was fetched for this region: a batched fetch replaces the whole payload, so a region an earlier batch loaded keeps its `loadedRegions` entry with nothing behind it. In columns, also whether it was fetched at the zoom on screen.
configuredFilters `() => string[]`	The filters the `filter` config slot holds.
baseFilters `() => string[]`	What the track's config declares for `filter`, which "Clear all filters" returns to.
featureById `(featureId: string) => Feature \| undefined`	The record a click on the rows, the lane or the matrix resolved to, positional fields only: its genotypes live in the cell payload.
expandRows `(rows: ProcessedSource[]) => ProcessedSource[]`	`TreeSidebarMixin`'s hook: phased mode draws a row per haplotype, once `samplePloidy` lands or the order names them.
rpcProps `() => { layout: "columns" \| "genomic"; sampleFilter: string[] \| undefined; minorAlleleFrequencyFilter: number; maxMissingnessFilter: number; filters: SerializableFilterChain \| undefined; unit: "haplotype" \| "sample"; color: CellHueRead; referenceDrawingMode: string; }`
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`	Items for the right-click menu, built from the record `contextMenuInfo` carries.
connectorLineAtScreenX `(screenX: number) => ConnectorCoord \| undefined`	The connector for the column under `screenX` (the crosshair), or undefined off the ends and over a column with no genomic x.
laneLayoutAt `(showLabels: boolean, showDescriptions: boolean) => Map<number, FeatureDataResult>`	One fit candidate: the lane's row packed with the given label reservation. Non-incremental, a band holding thousands of marks.
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`

15 inherited methods from 5 models

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

From MultiRegionDisplayMixin: isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, colorScalesIn, legendSpecIn

From TreeSidebarMixin: svgSidebarWidth, rowBand, dealtRowColorsFor, rowColorFor, rowOrderWillDropTree

Actions

Member	Description
setHoveredCell `(cell?: HoveredCell \| undefined) => void`
setHoveredLaneMark `(mark?: HitFeatureResult \| undefined) => void`
setHoveredMatrixCell `(cell?: MatrixHoveredCell \| undefined) => void`
clearHoveredFeature `() => void`	`StoredHoverMixin`'s clears the tooltip; the highlight boxes go with it.
setCellData `(data: CellDataResult \| undefined, displayedRegionIndices?: Iterable<number>, bpPerPx?: number \| undefined) => void`	Store a payload and the regions it covers. One payload serves every region of a fetch and replaces the last one whole, so this is also where the previous batch's regions stop having data behind them, and where a hover indexing the old payload's cells goes.
setFilter `(f?: string[] \| undefined) => void`
fetchAdapterMetadata `() => Promise<unknown>`	The adapter's header metadata, fetched once per adapter config.
selectFeature `(feature: Feature) => void`
setSources `(sources: Source[], adapterConfig?: any) => void`
setRowColorField `(field: string) => void`	Recolor sample rows by a metadata attribute (e.g. 'population'), or pass '' for None, through the mixin's `setRowColorChoice`. The tint is resolved on every read of `sources`, so a recolor moves no rows and drops no cluster tree.
setFacet `(field: string) => void`	Band the sample rows so each value of a metadata attribute (e.g. 'population') is contiguous, or pass '' to clear the facet. Writes the `facet` object, keeping a declared band order while the field is the one already banding, which is the whole of it: the banding is applied on every read of `bandedSources`, over the arranged order.
setMafFilter `(arg: number) => void`
setMaxMissingnessFilter `(arg: number) => void`
setUnit `(unit: "haplotype" \| "sample") => void`
setFitToHeight `() => void`	Enable fit-to-display-height mode: `rowHeight = 0` makes `effectiveRowHeight` divide `availableHeight` across the rows.
setReferenceDrawingMode `(arg: string) => void`
setShowRowSeparators `(arg: boolean) => void`
setShowTooltips `(arg: boolean) => void`
setShadeByDosage `(arg: boolean) => void`	Turn dosage shading on or off; the main thread repaints the loaded cells.
setShowVariantLane `(arg: boolean) => void`	Switch the variant lane on or off; it takes its space from the rows.
setVariantLaneHeight `(arg: number) => void`	Resize the variant lane, clamped here because a drag can deliver any number and a band dragged shut has to stay grabbable.
setVariantLaneLabels `(arg: "auto" \| "description" \| "name" \| "nameAndDescription" \| "none") => void`
setVariantLayout `(arg: "columns" \| "genomic") => void`
setLineZoneHeight `(n: number) => void`
setBackendDrawsColumns `(arg: boolean) => void`
sortByGenotype `(featureId: string) => boolean`	Order the rows by their genotype at one variant, ties broken by how far each row agrees with its neighbours to either side. Sorts `editableSources`, so the order written names every row.
sortRowsByGenotypeAt `(refName: string, pos: number) => boolean`	`sortByGenotype` at a genomic column, the declarative `sortRowsBy` entry point. Returns whether it sorted, so `sortRowsBy` stays set for the fetch that brings a record to the column. `refName` arrives canonical; a record's is whatever the file spelled.
clearDisplaySpecificData `() => void`
clearSettingsBakedData `() => void`
fetchNeeded `(_needed: IndexedRegion[]) => Promise<void>`
startRenderingBackend `(backend: VariantLayoutBackend) => void`	The layout's chrome hands over its backend; a layout switch mounts the other chrome, whose backend replaces this one. The upload lifecycle is installed once, so its cells and its render follow the backend attached rather than the setting: until the other chrome's backend arrives, the old one is sent nothing it cannot draw.