LinearVariantDisplay
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.
The variant display: a VCF's records stacked as a feature track stacks them, over one genotype row per sample, with the feature widget on a click on a record or a cell. With no sample rows the records are the display.
Example usage
rows and filter 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: 'LinearVariantDisplay',
displayId: 'my-cohort',
rows: {
field: 'haplotype',
sort: ['NA12878', 'NA12891'],
color: 'population',
},
filter: [{ field: 'minorAlleleFrequency', gte: 0.05 }],
},
]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: 'LinearVariantDisplay',
runClustering: true,
},
]How the rows are arranged
The arrangement is config: rows holds the order, the labels, the colors
pinned on rows, the cluster tree with its provenance and the focus, 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:
rows.filterand thenrows.keptnarrow the adapter's samples (adapterSamples) to the set the fetch asks for (sourcesBase,sampleFilter),- phased mode expands each sample to its haplotypes (
expandedRows), androws.sortorders them,rows.labelsrelabels them and each row has its resolved color (arrangedRows, the dialog's list), each fromTreeSidebarMixinover this display's hooks, - the same narrowing narrows those (
shownRows, what a run clusters), facetstacks those in bands (stackedRows), each band's rows in their arranged order,- the result is
drawnRows, each row's resolved color its label bar.
rows.color wins over a color the row already has, a samplesTsv
color column: a channel bound to a variable beats a per-row constant, so
"Color by… → (none)" restores the row's color from that column. A color
the dialog pins on a row (rows.colors) wins over both.
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.
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"LinearVariantDisplay" |
Always "LinearVariantDisplay", the name a snapshot selects this model by. |
configurationLinearVariantDisplayConfig |
The config node this model reads its settings from, through getConf. Its slots are documented on its config schema page. |
featureHighlightstypes.stripDefault( types.array(FeatureHighlightModel), [], ) |
The records a search hit, a right-click or the highlight= param boxes on the records band, as on a feature track. |
5 inherited properties from 3 models
From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy
From ParkedColorMixin: parkedColors
From BaseDisplay: id
Volatiles
| Member | Description |
|---|---|
sampleListingAdapterRead<Source[]> | undefined |
The adapter's sample list, stamped with the adapter config it answers. |
sampleWarningsstring[] |
What the samples table disagreed with the VCF's samples about, as the sample list came back with it. |
cellDataCellDataResult | undefined |
The fetched per-display data, replaced whole by each fetch. |
cellDataRegionIndicesReadonlySet<number> |
The displayed regions the current cellData was fetched for. The payload does not list them: a region with no variants gets no perRegionCellData entry, and the columns payload is one entry for every region. |
cellDataBpPerPxnumber | 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. |
hoveredVariantHover | undefined |
The mark under the pointer, in whichever band it sits: a genotype cell, a record on the records band or a matrix cell. One slot, so a hover in one band ends the last one's highlight. |
backendDrawsColumnsboolean |
Whether the attached backend draws columns, so the upload sends it the payload it can draw across the swap a layout change makes. |
openingHeightnumber | undefined |
The records-only height this display opened at (settleRecordsOpeningHeight), held while no height is written. |
openingRecordsHeightnumber | undefined |
The records band's height over rows at its opening (settleRecordsBandHeight), held while no records.height is written. |
28 inherited volatiles from 10 models
From ContextMenuMixin:
From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas
From StoredHoverMixin: storedHoveredFeature
From LegendMixin: dismissedLegendSections
From FeatureGateMixin: densityStatsPerRegion
From MultiRegionDisplayMixin: loadedRegions
From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, error, statusMessage, statusProgress, fetchCanceled, fetchRotation
From RenderLifecycleMixin: canvasDrawn, paintCount, currentRenderingBackend, renderTick, renderError, offScreen
From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey
From TrackHeightMixin: scrollTop, hostHeight
Getters
| Member | Description |
|---|---|
hoveredCellHoveredCell | undefined |
The genotype cell under the pointer. |
hoveredRecordHitFeatureResult | undefined |
The record under the pointer on the records band, plugin-features's hit result, so hoverInk lights the box the band painted. |
hoveredMatrixCellMatrixHoveredCell | undefined |
The matrix cell under the pointer, in the equal-width column layout. |
adapterSamplesSource[] | undefined |
The samples the adapter lists, undefined until the current adapter config's list lands. |
genotypeSampleIndexMap<string, number> | undefined |
sampleName -> column of each feature's interned genotypeCodes, for the tooltips (genotypeCodec.ts). |
viewLinearGenomeView |
|
hasPhasedOrHaploidboolean |
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. |
hasConsequenceboolean |
Whether any visible variant has a SnpEff/VEP annotation, gating the "Color by→Consequence impact" menu option. |
hasSvTypeboolean |
Whether any visible variant is a structural variant, gating the "Color by...→SV type" menu option. |
hasPhaseSetboolean |
Whether any visible variant declares a phase set (PS in FORMAT), gating the "Color by→Phase set" menu option. |
samplePloidyReadonly<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. |
rowsField"haplotype" | "sample" |
|
facetFacetSetting | 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. |
genotypesShowWrittenboolean |
Whether genotypes.show is written, by config or by the menu. |
genotypesShowDefaultboolean |
What an unset genotypes.show resolves to: every VCF but a one-sample one draws its rows. |
showGenotypesboolean |
genotypes.show: whether the display reads genotypes and draws a row per sample. Unset, genotypesShowDefault. |
colorSettingColorSetting |
encoding.color as written, value raw: a jexl: callback is the worker's to evaluate per variant. |
colorEncodingstring | FieldColorEncoding | undefined |
What the alt cells' hue paints: undefined for the genotype colors, a CSS color or jexl: callback, or a field through its ordinal or threshold scale (shared/cellHue.ts). |
genotypesShowClearableboolean |
Whether genotypesShowDefault is the answer rather than a guess made before the samples loaded, and the track entry the display came from leaves genotypes.show unset. Only then is a value equal to the default the same state as unset. |
showRowSeparatorsboolean |
|
showTooltipsboolean |
Whether a hover draws the tooltip table. The crosshairs, the hovered-cell highlight and hoveredFeature keep working with it off. |
liveNoticesstring[] |
What the samples table disagreed with the VCF's samples about, rowNotices, and each filter field no loaded variant carries, pointing at rows.filter where it is a row attribute. |
colorFieldstring |
The field the alt cells paint by, '' while they paint the genotype colors or a constant. |
featureWidgetType{ type: string; id: string; } |
|
featureNounstring |
The noun the feature menu rows name a record by: "Zoom to variant". |
canonicalTranscriptsCanonicalTranscripts |
The sequence dialog's isoform tags; a record has no isoforms, so the defaults. |
inRingboolean |
Whether a circular view's ring hosts the display (hostHeight). The ring samples one canvas of its strip, the records band's. |
recordsOnlyboolean |
Whether the records band is the display, every record the filter admits, sized by heightMode and lettered as a feature track: a VCF with no samples, a one-sample call set whose row nobody asked for, or a ring, which draws one canvas and so the records alone. |
drawsGenotypeRowsboolean |
Whether genotype rows draw: genotypes.show, on a VCF with samples. Hidden, the rows take no height and the records band is the track. |
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: the variantLayout slot while genotype rows draw. Columns lay out rows, so with none (no samples, or genotypes.show off) the records band draws at genomic positions, and the slot's columns come back with the rows. |
atGenomicPositionsboolean |
|
rowFocusreadonly string[] | undefined |
rows.kept while genotype rows draw; with none no focus applies, so no "Showing N of M rows" chip takes a line over the records band. The focus comes back with the rows. Overrides TreeSidebarMixin.rowFocus. |
rowFilterreadonly FieldPredicate[] |
rows.filter while genotype rows draw, as rowFocus reads rows.kept. Overrides TreeSidebarMixin.rowFilter. |
discoveredRowsProcessedSource[] |
TreeSidebarMixin's hook: the adapter's samples as rows, each answering to its sample name, a samplesTsv color column the row's own color. Empty while no row draws. |
connectorsBandBand |
The connectors band above the columns, taken from the rows' slot height so they keep their floor; nothing at genomic positions, where nothing needs connecting. |
connectorsStackBandStack<"connectors"> |
|
connectorsHeightnumber |
|
rowsListedUpFrontboolean |
TreeSidebarMixin's hook: the VCF lists its samples, so a rows.kept name no sample has is named. |
showRecordsboolean |
Whether the records band is drawn: at genomic positions only, where a record lines up with the cells under it, and always while no row draws. |
recordsColorBySvClassboolean |
Whether the records band colors by SV class, the rest featureDefaultColor: while no encoding.color is picked, with rows or without, and under phaseSet, a genotype's value that no record holds. Any other picked color paints the records as it paints the cells. |
cellColorKeyedboolean |
Whether the cells' coloring is keyed: always while rows draw; with none only under a picked encoding.color field whose values the records paint. A constant paints every record alike, and phaseSet paints them by SV class, so neither keys a cell nothing draws. |
recordsHeightWrittenboolean |
Whether a drag, +N hidden or a config wrote records.height. |
recordsHeightHeldboolean |
Whether the band's height holds: written, or settled at its opening. Until then the band over rows is its stack, up to the default. |
recordsHeightnumber |
records.height, else the height the band opened at, else the default it opens at up to its stack. Raw: what the band spends is topBands.reserved.records. |
recordsLabelsRecordsLabels |
The field each label kind of the records band reads, empty where it is hidden; what it draws is recordsRenderedLabels. |
recordsFacetFacetSetting | undefined |
records.facet as written, or undefined while the records stack in one section. The display's own facet bands the sample rows. |
ReadonlySet<string> |
The record sections the user hid, records.facet.hidden. |
recordsFeatureHeightnumber |
records.mark.height, each record's body at normal. |
recordsTooltipFieldstring |
records.tooltip.field, the record's line in the hover tooltip. |
recordFieldReadsRecordFieldReads |
What the worker reads off each record for the band beyond the payload: a tooltip or label field other than its default, which the band reads off the payload's own name and description, and the records' facet field. A label is read shown or hidden, so its checkbox redraws rather than refetches. |
recordsDisplayMode"collapsed" | "compact" | "normal" | "superCompact" |
records.displayMode, and unset the one rule its default follows: compact over rows, tight with its one label line; with no rows normal, a feature track's default. |
recordsFontSizenumber |
The size the band letters at, plugin-features's for its display mode, so the width its packer reserved is the width the text draws. |
growMaxHeightnumber |
HeightModeMixin's ceiling on grow: the slot's with no rows; over rows none, so height holds in every mode. |
densityGateActiveboolean |
The density axis acts only on a VCF with no samples, where the records are the display, as on a feature track, always at genomic positions. Over rows, shown or hidden, the byte gate alone guards the fetch. |
configuredMaxFeatureScreenDensitynumber |
records.maxFeatureScreenDensity, the density budget. |
sourcesBaseSource[] | undefined |
The adapter's samples narrowed by rows.filter over their samplesTsv attributes and then rows.kept, none while no row draws: the row set the fetch asks for, so it must not read samplePloidy. The attributes arrive with the sample list, so the filter never runs ahead of them. undefined until the samples land; that transition wakes the fetch autorun (reference/FETCH_KEYS.md). |
sampleFilterstring[] | undefined |
Which samples the worker emits rows for, as a sorted set: row order is not a fetch input (reference/FETCH_KEYS.md). Empty while no row draws, so the worker reads no genotype and tests no site field, as for a sites-only VCF. 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 drawnRows, which reads the fetch-derived samplePloidy. |
siteFilterFieldPredicate[] |
The filter list's site fields, minorAlleleFrequency and missingness, which the worker tests off each site's allele summary. |
filtersSerializableFilterChain | undefined |
The filter list's other entries as the RPC's filters arg. |
showReferenceboolean |
genotypes.reference.show: each reference call draws as a cell, rather than the rows' grey fill standing in for it. |
rowBackgroundstring |
The fill behind the rows, standing in for every reference call that draws no cell: '' under showReference. |
minMinorAlleleFrequencynumber |
The floor the filter puts on minorAlleleFrequency, 0 for none: the slider's value |
maxMissingnessnumber |
The ceiling the filter puts on missingness, 1 for none: the slider's value |
internalRowFieldsreadonly string[] |
TreeSidebarMixin's hook: a haplotype row's sampleName, HP and sole, which the arrangement dialog lists as no column. |
rowColorFieldsreadonly string[] |
TreeSidebarMixin's hook: the samplesTsv attributes, the ones "Color by" and "Group by" offer — every sample key except internal ones. |
finerTreeHint{ text: string; title: string; } |
TreeSidebarMixin's hook: a tree clustered per haplotype hides in sample mode, and says so. |
rowColorPaintsMarksboolean |
TreeSidebarMixin's hook: never, since the cells paint by genotype and a row's color shows only on its label bar. |
rowBandingRowBanding | undefined |
TreeSidebarMixin's hook: the facet bands the rows by a samplesTsv attribute. |
finerRowsProcessedSource[] |
TreeSidebarMixin's hook: the haplotype rows phased mode draws, or would, so an order or a focus naming a haplotype reaches a sample row standing for it: in sample mode, a sample ranking at its first haplotype entry, and in phased mode before the ploidy lands. The same array while a write names no new haplotype, so a focus or a reorder re-arranges nothing for it. |
clusteringReadyboolean |
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. |
hasClusterableRowsboolean |
Whether there are at least two rows on screen to put in an order, counted over shownRows, the list a run clusters. |
autoClusterReadyboolean |
Whether the declarative runClustering: true path may fire: the fetched inputs have landed and two or more rows are on screen. |
| cellHueInput |
The painted encoding.color, the field kept beside it and the field an identity scale paints, which cellHue resolves. Compared by value, so editing the key's title or names repaints nothing. |
cellHueReadCellHueRead |
What the worker reads off each variant for the alt cells' hue, apart from the loaded values a ramp follows. |
cellHueValuesReadboolean |
Whether the held payload's color values were read for the current encoding.color; one read for another paints as though it read none. |
cellHueCellHue |
Where the alt cells' hue comes from: what the worker reads and how the main thread paints it (cellHueOf), a ramp over the values every fetched region read. |
cellPaintOptions{ phased: boolean; valuesRead: boolean; } |
How the held payload's alt cells paint (paintCellColors). |
| keyWindows |
The bp each displayed region shows once a pan settles, which the key lists what is present in. Compared by value, so a pan that settles where it was rebuilds no key. |
keyedVariantsKeyedVariants |
What the key lists, read off the variants in keyWindows at genomic positions (the fetch is wider than what shows) and off every fetched variant in columns, which fetch only what is shown. |
hasSecondaryAltboolean |
Whether a variant on screen painted a secondary-alt cell, which keys the "Other alt allele" legend entry. Painted, not possible. |
hasAltWithoutPhaseSetboolean |
Whether phase-set coloring painted an alt cell on screen whose call names no phase set, which keys that cell's plain hue. |
hasUnphasedboolean |
Whether a variant on screen painted a black unphased cell (drives the "Unphased" legend entry). |
hasNoCallboolean |
Whether a variant on screen painted a no-call cell (drives the "No call" legend entry). |
paintedDomainstring[] |
The cell scale's domain values painted on screen — the impact tiers or SV classes the legend lists: every record's while the records band paints them, which covers each alt cell's, else those an alt cell was painted for. |
regionRecordColorsMap<number, Uint32Array<ArrayBuffer>> |
Each fetched region's record colors: the SV class or featureDefaultColor (svClassColors), or under a picked encoding.color the alt cells' hue at full dose, which neither shading nor the phased mode moves. |
recordCarrierSamplesreadonly string[] |
The samples a record's carrier share is out of: the ones shown as rows, so it matches the matrix under it. A haplotype row counts as its sample. |
recordCarriersOf((info: CountedRecord) => RecordCarriers) | undefined |
A record's carriers among recordCarrierSamples, counted when a drawn label or a hover first asks and held per payload and row set; undefined with no rows to carry it. |
recordsLayoutInputsFeatureBandHost['layoutInputs'] |
What the band's packer reads, minus the label reservation each fit rung varies. coarseBpPerPx, so packing does not recompute per frame of a zoom. |
| recordsSpans |
The spans of the records the band draws, per fetched region, once per payload. |
ReadonlySet<string> | undefined |
The records of the sections the user hid, as LinearBasicDisplay's hiddenGroupFeatureIds: once per payload, facet and hidden set, not per pan. |
recordsOnScreenIdsReadonlySet<string> |
The records the band draws whose span touches the screen, as LinearBasicDisplay's onScreenFeatureIds: what its labels gate on, so records buffered off screen cost no label. None before the view has a width to lay its blocks out across. |
recordsMeasureIdsReadonlySet<string> | undefined |
The records the band's fit and height measure: with no rows those on screen, as a feature track measures; over rows every fetched one, so the rows under the band hold still between fetches. |
recordsLabelDensityPerPxnumber |
Records on screen per pixel of the blocks on screen, as LinearBasicDisplay's labelDensityPerPx. |
recordsPackMode"collapsed" | "compact" | "normal" | "superCompact" |
The display mode the band packs at: records.displayMode, except over rows past records.maxFeatureScreenDensity on screen, where the records collapse into one row, the density at which a feature track refuses the window, as the records-only display does. |
recordsVisibleLabelsRecordsLabels |
recordsLabels past LinearBasicDisplay's label density rule (labelVisibility): names go past 0.2 records per pixel on screen and descriptions past 0.1, as on a feature track. |
| recordsLabelPlan |
How the band letters its records: with no rows as a feature track does, a name line and a description line off the label fields; over rows one recordLabel line carrying both, built into each record. lettered is which kinds it letters before the fit ladder, on lines of their own or on the one line. |
recordsRenderDataMapReadonlyMap<number, LayoutRegionData> |
The band's records as plugin-features render data, one entry per fetched region, empty while the band is off. Keyed off the payload and the displayed regions' bounds, never the row-placed map or visibleRegions, which would rebuild it per reorder or per frame. |
recordsColorScalesColorScale[] |
The key to the records band's SV classes, the ones its records on screen hold, while it colors by them. |
sourceMapMap<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. |
rowRemapUint32Array<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 not the screen order. |
SvgSidebarProps |
|
availableHeightnumber |
Height left for the rows under the bands above them, floored at 0: every consumer treats it as a pixel dimension. 0 while no row draws. |
nrownumber |
|
autoRowHeightnumber |
What fit-to-display-height divides between the rows. |
| topBands |
The bands stacked above the rows, resolved once: the layout below and the painters read this instead of summing the bands (variantTopBands.ts). The records band is records.height once written, its full rung's stack up to the default before. |
growTargetHeightnumber |
HeightModeMixin's hook: with no rows, the records' full stack on screen, as LinearBasicDisplay grows to its features; over rows the slot height, so grow keeps the rows' height. |
recordsFitStageFitStage |
The rung the band keeps and the scale that fits it, off LinearBasicDisplay's ladder run against recordsHeight: under the cap the full rung fits at scale 1; past it descriptions go, then bodies thin, names decimate, names go, and the boxes squeeze. |
recordsLaidOutDataMapReadonlyMap<number, FeatureDataResult> |
What the band's painter, labels and hit test all read: the kept stack. With no rows it is scaled when the fit squeezed it, as a feature track's; over rows it never squeezes, and past the ladder's last rung a record that does not fit the band hides. |
number |
How many records on screen the band leaves unplaced, past its height over rows. |
recordsStackHeightnumber |
The band's whole stack at full size, labels included: the height at which no record hides. |
recordsGroupSectionsFeatureGroupSection[] |
The record sections in stacking order, each with the chip row the packer reserved above it; empty while the records are one section. |
recordsRenderedLabelsLabelPlacementContext |
Which label kinds the band paints: what the kept rung reserved, so a box never claims width for a description the band had no room for. |
recordsLabelFitHints{ names: string | undefined; descriptions: string | undefined; } |
The note on the records' Names and Descriptions checkboxes while the band's fit ladder is not honouring them. Over rows both ride the one label line, so the line's note is the descriptions' too. |
recordsFlatbushIndexesReadonlyMap<number, FlatbushRegionIndexes> |
Per-region hit index over the band's laid-out records, off the painted stack and the RENDERED label flags, a label's overhang being part of its hit box. Held alive by the RecordsHitIndexes autorun across pointer frames. |
recordsRegionInstanceIndexesReadonlyMap<number, RegionInstanceIndex> |
The band's record ids to the primitives they painted, per region. Held by no autorun, as a feature track's: built when a hover or a highlight first asks, and the per-region memo outlives the computed. |
rowsHeaderHeightnumber |
TreeSidebarMixin's hook: the records band and the connector-line zone, which rowsTopOffset stacks the focus chip's line under. |
rowsHeaderControlsHeightnumber |
TreeSidebarMixin's hook: the chips' strip, which holds only controls. It shows only at genomic positions, where the connectors take no height, so it sits directly above the focus chip's line. |
recordsChipsHeadBandboolean |
Whether the records' chips head the band rather than sit in the strip: while the genotype rows draw under it, so the two read as subtracks, and it is taller than a chip. With the rows hidden the records have no × to show. |
recordsSectionChipsDrawnboolean |
Whether the band's top holds its sections' chips (records.facet), which then carry the records' chips ahead of the topmost. |
scrollContentHeightnumber |
The rows; with no rows the records' drawn stack on screen, as a feature track scrolls what fixed or a capped grow cannot show. |
scrollViewportHeightnumber |
|
recordsScrollTopnumber |
How far the records band is scrolled: the display's scrollTop with no rows, where the band is what scrolls, else 0. |
layoutReadyboolean |
MultiRegionDisplayMixin's hook: whether searchFeatureByID has a laid-out band to search, so an overlay can tell a record off the band from a band not laid out yet. |
heightWrittenboolean |
Whether a config, a session or a user's act wrote height. |
configuredHeightnumber |
height as written, else, with no rows, the height the track opened at, else the default. Overrides TrackHeightMixin.configuredHeight, so a drag, fit and the grow-exit bake start from the height on screen. |
boolean |
Genotype rows hidden on a VCF with samples: the band and its chip strip are all the track draws, and the slot waits for the rows' return. |
recordsAlone{ height: number; fits: boolean; } | undefined |
The records band as the whole track, which the R export hands over as a feature track: the height it draws at, and whether it fits its records into that height, as it does over hidden rows. Undefined while genotype rows draw. |
heightnumber |
Over genotype rows the records band and its chip strip add their height to the track above them, so the rows keep the slot's height; with the rows hidden the track is the band and its chip strip. With no samples, or in a ring, the band is the display, sized by heightMode. Overrides HeightModeMixin.height. |
recordsInkHostFeatureInkHost |
The band as plugin-features's ink reads a feature track: its stack, its scroll and height, and the labels it drew. |
selectionInkHighlightRect[] |
HighlightHost's selection: the selected record's box on the band. |
resolvedHighlightsResolvedHighlights |
Which band records each stored highlight boxes. A record the band holds no data for (outside the fetched regions) boxes nothing. |
highlightedFeatureIdSetReadonlySet<string> |
The band records any highlight boxes, what the Highlight row reads. |
pinnedInkHighlightRect[] |
HighlightHost's pinned boxes: each highlighted record's box on the band, as the hover box lights it. |
rowUnmapInt32Array<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. |
hoveredTooltipSourceVariantHoverFields | undefined |
The hovered thing as the tooltip table reads it. Undefined with tooltip.show off. |
matrixWidthnumber |
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 |
|
gateEnabledboolean |
Opt into RegionTooLargeMixin's byte gate. |
prefersOffsetboolean |
Genotype rows fill the track, so an overlapping track label would sit on top of a sample's genotypes. With none the records band is the track and takes the offset as a feature track does, while its sections' chips sit where the label would. |
awaitingPrerequisiteboolean |
fetchNeeded declines until sourcesBase lands, so the retry contract is judged on the run that follows (FetchMixin.awaitingPrerequisite). |
densityRungnumber |
The power-of-two zoom the density fade is computed at, so a zoom inside one rung repaints and re-uploads no cell. |
regionRecordAlphaMap<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 |
regionCellColorsMap<number, Uint32Array<ArrayBufferLike>> |
Each fetched region's cell colors through the current encoding.color, faded where records share pixels. Apart from the rows, so a reorder repaints nothing, and a recolor re-places nothing and refetches nothing. |
placedRegionRowsMap<number, Placed<VariantCellData>> |
Each fetched region with its rows placed on screen. A computed apart from the colors, so a recolor leaves it standing. |
regionCellGlyphsMap<number, CellGlyphs> |
Each fetched region's cells as the cell mark's attributes: the record's span and glyph, which the payload holds once per record, dealt to each of its cells. Off cellData alone, since neither a reorder nor a recolor moves a cell's span. |
paintedRegionRowsMap<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 |
The one walk of the payload every genomic-position consumer reads: paintedRegionRows with the cell mark's attributes. |
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. |
matrixBlocksRenderBlock[] |
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. |
connectorLineCoordsConnectorCoord[] |
The connector lines that draw: those with a genomic x. |
litRecordIdstring | undefined |
The band record the hover box lights: the one a menu opened on while it is open, else the one under the pointer, as LinearBasicDisplay's hoverBoxFeature picks. |
hoverInkHighlightRect[] |
The box of the lit record, over its glyph and its labels as LinearBasicDisplay boxes a feature, else of the hovered genotype cell. |
genotypeHoverInkHighlightRect[] |
The box of the hovered genotype cell: its instance through the cell mark's ink, moved down by the bands above the rows. |
highlightStyleHighlightStyle |
A record shades as a feature track's feature does; a cell takes a wash and a border, since the cell colors are the data. |
featureIndicesMap<number, Flatbush> |
Per-region spatial index over feature intervals, for the hit-test. One entry per variant, not per cell — see computeVariantCells. Off the payload alone, since neither a reorder nor a recolor moves a span. |
dataColorScalesColorScale[] |
The records band's SV classes and, while cellColorKeyed, the cell coloring (variantDataColorScales): the display's colorScales less the row color key. |
colorScalesColorScale[] |
LegendMixin's hook: the records band's SV classes, the cell coloring while cellColorKeyed, and the row color key. |
117 inherited getters from 15 models
From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowSort, rowLabels, storedRowTree, rowTreeProvenance, rowColorChannel, rowColorPins, rowAnnotationChannels, baseRowColorChannel, baseRowColorSetting, rowColorIsCustom, rowColorChoice, rowColorFieldsOffered, rowArrangementIsCustom, rotatableRowTree, rowsContentHeight, hierarchy, , , awaitingDependentData, spatialIndex, clusterPartition, treelessBandCount, baseRowFilter, rowBandingNotices, rowNarrowingClears, rowNarrowingNotices, rowNotices, rowNarrowingHint, treeOnFinerRows, treeHasBranchLengths
From StoredHoverMixin: hoveredFeature
From RowHeightMixin: rowStep, effectiveRowHeight
From FacetWritesMixin: writtenFacet
From ColorWritesMixin: writtenColor
From ParkedColorMixin: parkedColor, parkedIdentity
From LegendMixin: showLegend, legendRight, legendTop, legendSpec, hasLegendKey, keyDrawnByHost
From FeatureGateMixin: visibleFeatureDensityPerPx, maxFeatureDensity, densityTooLarge
From MultiRegionDisplayMixin: host, canvasWidthPx, settledSubPixelBinBp, canRender, rendersCanvas, trackVisibleRegions, viewportWithinLoadedData, viewportEmpty, fetchSuspended, dataSuperseded, renderBlocks, fetchInputs, regionPayloads, hasRegionData, staleSettingsDrawn, dataCurrent, loadedAssembly, phaseViewportCurrent, svgReady, paintInert, paintSuperseded, displayPhase
From FetchMixin: isLoading, isLoadingOrCanceled, fetchInert, settingsFetchInputs
From RenderLifecycleMixin: painted
From RegionTooLargeMixin: byteGateAdapterConfig, byteGateAdapterPath, adapterFetchSizeLimit, gateViewportSpanBp, gateViewport, configuredFetchSizeLimit, configForceLoad, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateByteLimit, gateActive, gateMeasurementStale, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport
From HeightModeMixin: heightMode, autoHeight, fitHeightToDisplay, fitTargetHeight, grownHeight, hostInitialized
From TrackHeightMixin: allottedHeight, resizing, scrollableHeight
From BaseDisplay: parentTrack, selectedFeatureId, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, plotKeys, plot, configNotices, notices, cornerNotices, plotExamples, configDocsUrl
Methods
| Member | Description |
|---|---|
featureInfoById(featureId: string) => VariantFeatureInfo | undefined |
The payload's record behind a cell. |
simplifiedFeatureById(featureId: string) => SimplifiedVariantFeature | undefined |
The payload's positional record behind a cell. |
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 jexl: expressions the filter list holds. |
baseFilters() => string[] |
The expressions the track's config declares, which "Clear all filters" returns to. |
featureById(featureId: string) => Feature | undefined |
The record a click on the rows or the matrix resolved to, positional fields only: its genotypes are in the cell payload. |
| The right-clicked record as the hit plugin-features's feature menu rows act on, in the displayed region the hit was drawn in, else the first loaded one it overlaps. | |
rowParent(row: ProcessedSource) => RowParent | undefined |
TreeSidebarMixin's hook: a haplotype row refines its sample, read off the row's own sampleName and HP, so an order, a label, a tint or a focus written against a sample reaches each of its haplotypes, a label as Mother HP1; a haploid sample's one row takes the sample's label alone. |
expandRows(rows: ProcessedSource[]) => ProcessedSource[] |
TreeSidebarMixin's hook: phased mode draws a row per haplotype, once samplePloidy lands or the order names them. |
| rpcProps |
|
| searchFeatureByID |
Where a record drew, [startBp, top, endBp, bottom], as a feature track answers it: the breakpoint split view's overlay subtracts the display's scrollTop, so the top is the band's own, which over rows does not scroll. A record the band hides is not found. |
recordsInk(featureIds: Iterable<string>) => HighlightRect[] |
One box per region per record, over its glyph and the labels the band drew for it, in the display's px, as LinearBasicDisplay boxes a feature. No id reads nothing, so an empty selection or highlight list neither builds the band's indexes nor follows a pan. |
recordsDrawnLabelTexts(featureId: string) => Set<string> |
The text of every label the band drew for a record, which its hover tooltip leaves out, as a feature track's does. |
featuresNamed(name: string) => FeatureMatch[] |
The band's laid-out records this name or description labels, each with the box its body drew, as a feature track answers it. Built only when called. |
tooltipSourceOf(hit: VariantHoverFields) => VariantHoverFields |
A hit as the tooltip table reads it: the record's fields over the hit row's sample metadata. |
tooltipTextOf(hit: VariantHoverFields) => string | undefined |
The tooltip a hit shows, as plain text, for "Copy tooltip text"; undefined with tooltip.show off. |
() => MenuItem[] |
|
() => MenuItem[] |
Items for the right-click menu, built from the record in contextMenuInfo. |
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. |
renderSvg(opts?: ExportSvgDisplayOptions) => Promise<ReactNode> |
20 inherited methods from 7 models
From TreeSidebarMixin: rowFoundAtSomeLoci, , rowColorFor, orderDropsRowTree, rowOrderWillDropTree, unreadFilterFieldNotice, rowAnnotationNotices
From ParkedColorMixin: parkedColorOf
From LegendMixin: colorScalesIn, legendSpecIn
From FeatureGateMixin: observedMaxDensity
From MultiRegionDisplayMixin: isCacheValid
From RegionTooLargeMixin: gateFetchState, resolvedByteLimit
From BaseDisplay: renderingProps, exportedFeatures, configProblemsOf, liftPlot, plotProblems, plotWrites
Actions
| Member | Description |
|---|---|
setHovered(hovered?: VariantHover) => void |
|
clearHoveredFeature() => void |
StoredHoverMixin's clears the tooltip; the highlight boxes go with it. |
| setCellData |
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[]) => void |
|
fetchAdapterMetadata() => Promise<unknown> |
The adapter's header metadata, fetched once per adapter config. |
fetchFullRecord(feature: Feature) => Promise<Feature> |
The clicked record as the adapter holds it, INFO and every sample included, as LinearBasicDisplay's fetchFullFeature reads it: the cell payload carries positions and genotype codes, no INFO. The clicked cell's sample card rides along; the click's own record where the adapter finds none. |
selectFeature(feature: Feature) => void |
|
clearSelection() => void |
|
| fetchFullFeature |
A drawn record as the adapter holds it, INFO and every sample included, as LinearBasicDisplay's fetchFullFeature answers its feature menu's copy and sequence rows. |
setSequenceHoverPosition(_pos: SequenceHoverPosition | undefined) => void |
Where the sequence dialog's pointer is, which a feature track boxes on its glyph. A record's sequence is its REF span, so nothing here draws it. |
| setSources |
|
setRowColorChoice(choice: string) => void |
The mixin's, then a warning naming a metadata field no sample carries. The tint is resolved on every read of drawnRows, so a recolor moves no rows and drops no cluster tree. |
setMinMinorAlleleFrequency(arg: number) => void |
|
setMaxMissingness(arg: number) => void |
|
setShowReference(arg: boolean) => void |
|
setShowRowSeparators(arg: boolean) => void |
|
setShowTooltips(arg: boolean) => void |
|
openSolidColorDialog() => void |
the picker Color by's Solid color... opens |
setVariantLayout(arg: "columns" | "genomic") => void |
|
setConnectorsHeight(n: number) => void |
|
setShowGenotypes(arg: boolean) => void |
Draw the genotype rows, or the records alone. In columns this swaps the backend as setVariantLayout does, so it clears the render error the same way. A value the slot resolves to unset is cleared rather than written, since a written false keeps the band's look over rows (ADR-254). That holds only once the samples are known and the track entry the display came from sets no genotypes.show: a value the entry sets is written, so returning to it leaves no delta against it. |
setBackendDrawsColumns(arg: boolean) => void |
|
markRecordsBandPainted() => void |
The records band repainted its own canvas, the one a ring samples: counted as a paint so the ring takes the new picture, which the rows' backend never repaints for. canvasDrawn stays that backend's answer. |
setShowRecords(arg: boolean) => void |
Switch the records band on or off; over rows it adds its height to the track above them. |
| setRecordsDisplayMode |
records.displayMode, each record's height preset. |
setRecordsLabelShow(kind: "description" | "name", show: boolean) => void |
Show or hide one label kind of the records. |
recordsFacetByField(field: string) => void |
Split the records into sections by field, '' for none, keeping the order and hidden sections while it is the field already grouping. |
setRecordsFacetSort(sort: readonly string[]) => void |
The order the record sections take, the ones it names first. |
hideRecordsGroup(key: string) => void |
Drop a record section from the band; showAllRecordsGroups brings it back. |
showAllRecordsGroups() => void |
|
showAllRecordRows() => number |
Raise the band to its whole stack, so no record row hides; it never shrinks it. The +N hidden chip, and the track handle's double click with the rows hidden. |
resizeRecordsBand(distance: number) => number |
Resize the band by distance from what it draws, answering how far it moved, as resizeHeight answers for the track. A resize the clamp leaves where it is writes nothing, so an empty band pushed shut stays unwritten; one pulled open opens at least at the floor, since it is empty for want of records, not set below the floor. |
setRecordsHeight(height: number) => void |
The seam handle's drag: resizeRecordsBand to height. |
settleRecordsBandHeight() => void |
Hold the band's height over rows from its first layout of a fetched record at records.displayMode, not one collapsed past the density budget: what it draws then, its stack up to the default. From then on a pan fits the records inside the band rather than resizing it, and a region with no record before that spends nothing. Held on this display alone, never written, so viewing a track edits no session; a written records.height wins over it. |
resizeHeight(distance: number) => number |
With the rows hidden the track's edge resizes the records band; otherwise HeightModeMixin's, on the slot the rows draw at. |
expandToContentHeight() => number |
With the rows hidden the handle's double click grows the band to its whole stack, so no record hides; it never shrinks it. |
settleRecordsOpeningHeight() => void |
Hold a records-only track's height from its first layout with a record on screen: its full stack up to the default, so a sparse window opens compact. Once for this display, so a pan into a denser window fits the records inside the box rather than moving it. Held on this display alone, never written, so viewing a track edits no session; a written height wins over it. |
setFeatureHighlights(highlights: FeatureHighlight[]) => void |
|
setSearchHighlight(highlight: FeatureHighlight) => void |
A text search's highlight replaces the previous search's and leaves the right-click ones, which have a featureId, alone. |
addFeatureHighlightForItem(target: HighlightTarget, refName: string) => void |
|
removeFeatureHighlightsForId(featureId: string) => void |
|
clearFeatureHighlights() => void |
|
sortByGenotype(featureId: string) => boolean |
Order the rows by their genotype at one variant, then at the other records spanning its reference interval (a site split one record per ALT), then by how far each row agrees with its neighbours to either side. Sorts arrangedRows, so the order written names every row. |
sortRowsByGenotypeAt(refName: string, pos: number) => boolean |
sortByGenotype at a genomic column, the declarative sortRowsBy entry point. Anchors on the record a click there picks (pickVariantCell): the shortest covering the column, the later of two as short. 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. |
setRowsField(field: "haplotype" | "sample") => void |
What one row is, rows.field. A haplotype row is named by its sample name, so the arrangement is kept across the switch either way and a read interprets it at the field in force. |
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. |
72 inherited actions from 16 models
From ContextMenuMixin: ,
From TreeSidebarMixin: setShowTree, setShowBranchLength, setShowRowLabels, setTreeAreaWidth, setRunClustering, setClusterRegion, setSortRowsBy, setHoveredTreeNode, setTreeCanvasRef, setMouseoverCanvasRef, setRowOrder, setRowLabels, setRowFocus, showAllRows, applyRowEdits, resetRowArrangement, focusLegendEntry
From StoredHoverMixin: setHoveredFeature
From RowHeightMixin: setRowHeight, setFitToHeight
From FacetWritesMixin: facetByField, setFacetSort
From ColorWritesMixin: colorByField, setColorValue, colorByIdentity, colorByScheme, pickDefaultColor, pickSolidColor
From ParkedColorMixin: parkColor
From LegendMixin: setShowLegend, dismissLegendSection
From FeatureGateMixin: setDensityStats, clearGateMeasurements, commitGateMeasurements
From MultiRegionDisplayMixin: setLoadedRegion, evictRegionStore, dropLoadedRegion, clearAllRpcData, invalidateSettings, reload, fetchVisibleRegions, fetchRegions, afterAttach
From FetchMixin: setError, setStatusMessage, stopActiveFetch, openStatusStream, cancelFetch, cancelFetchByUser, beforeDestroy, beginFetch, endFetch, runFetch
From RenderLifecycleMixin: markCanvasDrawn, resetCanvasDrawn, stopRenderingBackend, renderNow, setOffScreen, setRenderError, attachRenderingBackend
From RegionTooLargeMixin: clearByteEstimate, setForceLoadTrack, commitFetchBytes, forceLoad
From HeightModeMixin: setHeightMode
From TrackHeightMixin: setScrollTop, setHostHeight, setHeight
Related links
- User guide: Clustering rows