MultiWaySyntenyDisplay

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

Draws a multi-genome ortholog track as one lane per assembly inside a linear genome view, with ribbons joining each gene's placements between adjacent lanes.

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('MultiWaySyntenyDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`
hiddenLaneNames `hiddenLaneNames: types.frozen<readonly string[] \| undefined>()`	the lanes a reader hid from the lane menu, by assembly name; the lanes chosen are `rows.kept`
frozenLanes `frozenLanes: types.frozen<FrozenLanes \| undefined>()`

1 inherited property from one model

From BaseDisplay: id

Volatiles

Member	Description
fetchedFeatures `{ anchor: string; features: Feature[]; ops: AlignmentOpsById; lanes?: string[] \| undefined; } \| undefined`
seenAttributeRanges `Record<string, AttributeRange>`
laneGenes `LaneFetchState<HeldLaneGenes>`
laneDescriptions `Map<string, AssemblyDescription>`
describedLanes `Set<string>`
lanesBeingDescribed `Set<string>`
releasedLanes `Set<string>`
laneLinks `LaneFetchState<HeldLaneLinks>`	per adjacent mate-lane pair, at the lanes' own coordinates
laneGroups `LaneFetchState<HeldLaneGroups>`	per mate lane, a gene table's rows on the lane's own window
laneLayerData `LaneFetchState<HeldLaneLayer>`
hoverTarget `HoverTarget \| undefined`
clickedTarget `RibbonRef \| undefined`
laneDecisions `Map<string, LaneDecision \| undefined>`
pinnedLanes `Map<string, LanePin>`
laneFlipPinsByAnchor `Map<string, ReadonlyMap<string, LaneFlipPin>>`
renderOriginPx `number`	the view's `offsetPx` the stack was last laid out against
laneTransitions `Map<string, LaneTransition>`
laneMotionClockMs `number`
laneMotionHalfway `ReadonlySet<string>`
laneDragPx `ReadonlyMap<string, number>`

24 inherited volatiles from 8 models

From BaseDisplay: error, statusMessage, statusProgress

From TrackHeightMixin: scrollTop, hostHeight

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

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

From KeyedFetchMixin: loadedFetchKey

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

From LegendMixin: dismissedLegendSections

From LodTierInfoMixin: adapterHeaderRead

Getters

Member	Description
declaredLanes `DeclaredLane[] \| undefined`
starAnchor `string \| undefined`
lgv 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<…>
features `Feature[] \| undefined`	undefined while the view's anchor differs from the fetch's
featureOps `AlignmentOpsById`
hoveredGroupKey `string \| undefined`
lodMode `LodMode`
hasLodCapableAdapter `boolean`
lodTier `LodTier`	read off the settled zoom, so a passing gesture refetches nothing
liveLodTier `LodTier`
canvasWidth `number`
viewSignature `string \| undefined`
groups `MultiWayGroup[]`
laneOpenings `(assemblyName: string, refName: string) => readonly LaneOpening[]`	each lane's holes, read off every fetched group rather than the viewport's, so one appears once both its pieces arrive and not as the second scrolls in
featuresAreNameless `boolean`
ribbonColor `string`
domain `string[]`
laneChoice `readonly string[] \| undefined`	`rows.kept` as a choice: undefined while it names no lane
ribbonColorField `string`
ribbonColorAttributes `string[]`
ribbonColorDomain `string[]`
ribbonPaint `SyntenyColorPaint`
ribbonAttributeRanges `Record<string, AttributeRange>`
hideUnlabelled `boolean`
drawCurves `boolean`
bridgeSkippedLanes `boolean`
showLaneTicks `boolean`
splitStrands `boolean`
showGeneLabels `boolean`
geneTextField `string`	a field, a jexl expression, or empty for the name-else-ID default
inlineLaneNames `boolean`
geneLabelPx `number`
laneLayerHeights `number[]`
layerPx `number`
geneColorSettings `GeneColorSettings`
geneColorEncoding `string \| FieldColorEncoding \| undefined`
geneColorSlots `HeldSlots \| undefined`	The slots a categorical gene color deals its values into.
geneColorField `string`	`''` while `color.value` paints
geneSolidColor `string \| undefined`	the constant `color.value` holds, undefined for none or a `jexl:` one
boxColors `GeneColors`
laneGeneColors `ReadonlyMap<string, GeneColors>`
selectedFeatureId `string \| undefined`
anchorAssemblyName `string`
adapterCapabilities `readonly string[]`
adapterDeclaresLanes `boolean`
adapterPairsOnAnchor `boolean`
adapterBatchesLanePairs `boolean`	the adapter answers a window's `lanePairs` in one call
sessionTracksById `ReadonlyMap<string, AnyTrackConfig>`	every session track, connections' included
adjacentLanesAlignDirectly `boolean`
rowsVsAnchor `boolean`	a source that names an anchor and answers no lane pairs states each lane against the anchor alone, so each gutter draws its lower lane against the anchor
pinnedLaneFlips `ReadonlyMap<string, LaneFlipPin>`
configuredLanes `string[]`	the track's assemblies beside the anchor for a source that declares its own lanes, empty for every other source
laneSelection `readonly string[] \| undefined`	undefined means every lane, and a hidden lane stays in force
hiddenLanes `readonly string[]`
fetchLaneSelection `string[] \| undefined`	undefined unless the adapter declares its lanes, and lists each held genome under every name the session knows it by
anchorAssembly (ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & { getCanonicalRefName2(refName: string): string; isValidRefName(refName: string): boolean; } & { isCircularRefName(refName: string): boolean; getRefNamePosition(refName: string): number \| undefined; getAliasesForRefName(refName: string): string[]; getRefNameMapForAdapter(adapterConf: AdapterConf, options: BaseOptions): Promise<…>; getRefNameMismatch(adapterCacheKey: string): RefNameMismatch \| undefined; } & IStateTreeNode<…>) \| undefined
anchorLocString `string`
declaredLaneLabels `Map<string, string>`	keyed by `laneKey`
laneUniverse `LaneChoice[]`	the anchor is never a lane
rowAssemblies `string[]`	a paralogy mate on the anchor assembly draws on its axis, not as a row
laneStructureOrder `string[]`	the drawn lanes chained by their deletions and insertions against the anchor, for "Order lanes by structure"; empty for a gene table
rowOfLane `ReadonlyMap<string, string>`	each drawn lane's row name by its canonical name, for data keyed by the records' spelling of a lane
lanesToDescribe `string[]`
laneAssemblyConfs `Map<string, Record<string, unknown>>`
canReanchor `boolean`
visibleBpSpan `number`
visibleGroupWindows `{ group: MultiWayGroup; start: number; end: number; }[]`	each with the hull, in anchor bp, of the settled blocks it meets
visibleGroups `MultiWayGroup[]`	uncut at the viewport edge, cut only at a displayed region's end
fitGroups `MultiWayGroup[]`	the visible groups cut to the viewport, which each lane's frame fits
tickIntervalBp `number`
scrollContentHeight `number`
laneGeneTracks `Map<string, AnyTrackConfig>`	keyed by each lane's own spelling, not by `laneKey`
laneGeneAdapters `Map<string, Record<string, unknown>>`
scrollViewportHeight `number`
anchorPlacements `Map<string, AxisPlacement>`	in view px before the scroll offset; a flipped view gives x1 > x2
dragOffsetPx `number`	the px the view has scrolled since the stack was laid out
anchorReversed `boolean`
anchorSpans `Map<string, Span>`	the anchor placements in stack px, relative to `renderOriginPx`
anchorAbsX `Map<string, { coord: AnchorCoord; x: number; }>`	each group's viewport-cut centre, in view px before the scroll offset
rowFrames `Map<string, RowFrame \| undefined>`
lanesFrozen `boolean`	true only while the view, on the anchor the lanes froze on, still shows part of the window they froze on
frozenDecisions `ReadonlyMap<string, LaneDecision>`	empty unless `lanesFrozen`
anchorFetchRegions `FetchRegion[]`
laneWindows `ReadonlyMap<string, LaneWindow>`	what each lane's dependent fetches ask for: the anchor's merged blocks, and each held, framed lane's window
lanePairs `LanePair[]`
anchorlessGroups `PlacedGroup[]`
laneGenesFetchSpecs `LaneGenesFetchSpec[]`
laneGroupsFetchSpecs `LaneGroupsFetchSpec[]`	a gene table read on each mate lane's window, for the rows the anchor lacks; a star source indexes its anchor alone, so it has none to give
laneLinksFetchSpecs `LaneLinksFetchSpec[]`	one spec per adjacent mate-lane pair whose gutter is on screen or within a screen of it
laneLayerTemplates `(Record<string, unknown> \| undefined)[]`
laneLayerSources `Map<string, LaneLayerSource>[]`
laneLayerReads `{ specs: LaneLayerFetchSpec[]; pastCap: boolean[]; }`	`pastCap` flags a layer that skipped a lane past `LANE_TEMPLATE_MAX_BP`
laneLayersFetchSpecs `LaneLayerFetchSpec[]`
laneStack `LaneStack`	carries no lane genes, so a gene commit re-uploads no ribbon or tick
laneMaps `ReadonlyMap<number, LaneMap>`
laneHeaderRows `LaneHeaderRow[]`
pairLinks `ReadonlyMap<string, LaneLinks>`	the alignments the source answered for each adjacent mate-lane pair, keyed `upper\|lower`; a pair it has not answered draws nothing
loadingGutterYs `number[]`	the centre, in stack px, of each gutter whose lane pair was asked for and has not landed
ribbonGeometry `RibbonGeometry`	in the stack's own px
tickGeometry `TickGeometry`
bandCell `MultiWayCell`
anchorTickXs `number[]`	px of the anchor's ticks across the displayed regions
laneCells `{ cells: Map<string, MultiWayCell>; boxNames: Map<string, NamedSpan[]>; geneGroups: Map<string, Map<string, string>>; }`	boxes before glyphs, so an in-order hit test finds a box over a gene
laneGlyphCells `Map<string, MultiWayCell>`
laneBoxNames `Map<string, NamedSpan[]>`
laneGeneGroups `Map<string, Map<string, string>>`	per lane, each drawn gene's group, keyed by feature id
pinnedLabelGroups `ReadonlySet<string>`
geneTextOf `(feature: Feature) => string \| undefined`
geneColorScales `ColorScale[]`	keys the anchor lane alone, over the settled window
colorScales `ColorScale[]`
legendRight `number`
laneLayerPlacements `{ specLane: string; held: HeldLaneLayer; row: number; top: number; height: number; segments: { start: number; end: number; px: Span; }[]; }[]`	each payload's region placed in its lane's own frame; a payload whose lane or contig no longer draws is left out
laneLayerDomains `([number, number] \| undefined)[]`	undefined for a layer no drawn lane holds values for yet
laneLayerColors `ColorSource[][]`	where each lane layer's marks take their color from, one per mark, read as the mark display reads its own
selectedGlyphHits `GlyphHit[][]`	the selected feature's glyph hits per row, which a pan leaves alone
laneLayerColorScales `(MarkColorScale \| undefined)[][]`	the ramp or threshold each lane layer's bars paint numbers through, one per mark and undefined for a mark colored another way; a ramp's domain covers the values of every drawn lane, as `laneLayerDomains` does for y, so one value takes one color in all of them
laneLayerTitles `{ key: string; text: string; top: number; }[]`
laneLayerCells `{ cells: Map<string, MultiWayCell>; layers: BarLayer[]; }`
namedCells `ReadonlyMap<string, MultiWayCell>`
namedLayers `MultiWayLayer[]`	back to front, bands first to cover the view's gridlines
hoveredFeatureId `number`
clickedFeatureId `number`
hoverInk `HighlightRect[]`
selectionInk `HighlightRect[]`
highlightStyle `HighlightStyle`
groundPalette `JBrowsePalette`
outlineCells `ReadonlyMap<string, MultiWayCell>`
renderCells `ReadonlyMap<number, MultiWayCell>`	keyed by `sharedBackendKey`
renderLayers `ReadonlyMap<number, MultiWayLayer>`	back to front, each outline immediately over the gutter it traces
ribbonRegions `ReadonlyMap<number, SyntenyInstanceData>`	in draw order
ribbonRecords `ReadonlyMap<number, ReadonlyMap<number, Feature>>`	`ribbonGeometry.records` keyed by `sharedBackendKey`
renderState `MultiWayRenderState`
renderBlocks `RenderBlock[]`
ribbonPickState `SyntenyRenderState`
animating `boolean`
laneFetches `{ state: LaneFetchState<HeldLane>; specs: LaneFetchSpec[]; }[]`
awaitingDependentData `boolean`
dataSuperseded `boolean`
hoveredFeature `Feature \| undefined`

61 inherited getters from 9 models

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

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

From GlobalFetchMixin: host, staticBlockSignature, dynamicBlockSignature, viewportEmpty, canRender, rendersCanvas, paintInert, svgReady, displayPhase

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

From RenderLifecycleMixin: paintSuperseded, painted

From KeyedFetchMixin: currentFetchKey, dataCurrent

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

From LegendMixin: showLegend, legendTop, legendSpec, hasLegendKey

From LodTierInfoMixin: adapterHeader, lodTierInfo

Methods

Member	Description
laneKey `(assemblyName: string) => string`	the canonical name, so two spellings of one assembly share a key
namedLaneTracks `(entries: readonly string[], key: string) => AnyTrackConfig[]`	the tracks `entries` names for the lane keyed `key`, best first: plain ids, then `{assembly}` entries, each in entry order
rpcProps `() => { haplotypes: string[] \| undefined; }`	reads only user-controlled state, never a fetch's output, or it loops
holdsAssembly `(assemblyName: string) => boolean`
holdsTemporarily `(assemblyName: string) => boolean`
laneLabel `(assemblyName: string) => string`
laneFrameOf `(decision: LaneDecision, assemblyName: string) => RowFrame \| undefined`	undefined once the pivot is off the displayed regions
laneDecisionsAt `(origin: number, previous: ReadonlyMap<string, LaneDecision \| undefined>, frozen: ReadonlyMap<string, LaneDecision>) => Map<string, LaneDecision \| undefined>`	in the px space anchored at `origin`; a lane in `frozen` keeps its own
bandCellOn `(page: string) => MultiWayCell`
laneGeneLabels `(fontFamily: string \| undefined, pinnedGroups?: ReadonlySet<string>, width?: number) => PlacedLaneLabel[]`	placed in the stack's px
coloredLayersOf `(held: HeldLaneLayer) => EncodedChannels[]`	a held payload's layers, each colored as its mark declares
pickRibbonAt `(x: number, y: number) => SyntenyPickResult \| undefined`	`x` and `y` are container-relative; the topmost ribbon wins
slidableLaneAt `(y: number) => string \| undefined`	`y` is container-relative; undefined unless the lanes are frozen
hitTest `(x: number, y: number) => HoverTarget \| undefined`	`x` and `y` are container-relative
trackMenuItems `() => MenuItem[]`

9 inherited methods from 3 models

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, colorScalesIn, legendSpecIn

Actions

Member	Description
setFeatures `(features: Feature[], anchor?: string, lanes?: string[] \| undefined, ops?: AlignmentOpsById) => void`
beginDescribingLanes `(names: string[]) => void`
endDescribingLanes `(names: string[], descriptions: Record<string, AssemblyDescription>) => void`
forgetUndescribedLanes `() => void`
setLaneGenes `(fetched: ReadonlyMap<string, HeldLaneGenes>, specs: LaneFetchSpec[], anchor: string) => void`	`specs` holds every lane the run was asked for, and `anchor` the anchor the specs were built under
setLaneLayerData `(fetched: ReadonlyMap<string, HeldLaneLayer>, specs: LaneFetchSpec[], anchor: string) => void`
setLaneLinks `(fetched: ReadonlyMap<string, HeldLaneLinks>, specs: LaneFetchSpec[], anchor: string) => void`
setLaneGroups `(fetched: ReadonlyMap<string, HeldLaneGroups>, specs: LaneFetchSpec[], anchor: string) => void`
setDomain `(domain: string[]) => void`	takes the whole pinned order, empty meaning densest-first; merge a partial one with `mergeDomain` first
setSelectedLanes `(names: readonly string[] \| undefined) => void`	writes `rows.kept`; undefined restores `configuredLanes`, or every lane
setBridgeSkippedLanes `(flag: boolean) => void`
setRibbonColorField `(field: string) => void`
setRibbonColorDomain `(domain: string[]) => void`
setHideUnlabelled `(flag: boolean) => void`
setDrawCurves `(flag: boolean) => void`
setShowLaneTicks `(flag: boolean) => void`
setSplitStrands `(flag: boolean) => void`
setInlineLaneNames `(flag: boolean) => void`
setShowGeneLabels `(flag: boolean) => void`
setGeneTextField `(field: string) => void`
setLodMode `(mode: LodMode) => void`
chooseLanes `(names: string[]) => void`
hideLane `(assemblyName: string) => void`
showLane `(assemblyName: string) => void`
showHiddenLanes `() => void`
openLaneSelection `() => void`
setLanesFrozen `(flag: boolean) => void`
realignLane `(assemblyName: string) => void`
nudgeLane `(assemblyName: string, dxPx: number) => void`	slides a mate lane `dxPx` screen px, only while the lanes are frozen
setLaneDragPx `(assemblyName: string, dxPx: number) => void`
endLaneDrag `(assemblyName: string) => void`
pinLane `(assemblyName: string, pin: LanePin \| undefined) => void`	a contig, or a block on it; `undefined` lets the lane choose again
flipLane `(assemblyName: string) => void`
unpinLaneFlip `(assemblyName: string) => void`
setLaneFrames `(originPx: number, decisions: Map<string, LaneDecision \| undefined>) => void`	`originPx` is the view offset the decisions' px space is anchored at
advanceAnimation `(nowMs: number) => void`
endAnimation `() => void`
setGeneColorBy `(field: string) => void`	`''` paints by `color.value`
setGeneSolidColor `(color: string \| undefined) => void`	Paints the constant, a field staying under `scale: 'none'` for the way back; undefined returns to the config's own color.
pickDefaultGeneColor `() => void`	Color by's Default: no field and no constant, so the config's own color paints, a `jexl:` expression included
pickGeneSolidColor `() => void`	Color by's Solid color...: paints the constant kept beside a field, where there is one, and opens the picker
selectFeature `(feature: Feature) => void`
openInNewView `(assemblyName: string, loc: string) => void`
reanchor `(assemblyName: string, loc: string) => void`
setHoverTarget `(target: HoverTarget \| undefined) => void`
startRenderingBackend `(backend: MultiWayRenderingBackend) => void`
setPointer `(state?: MouseState \| undefined) => void`
clearHoveredFeature `() => void`
selectHovered `() => void`
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactNode>`