MAIDR JavaScript API
    Preparing search index...

    Class VolcanoTrace

    Trace implementation for volcano and Manhattan plots.

    A volcano puts effect size against significance; a Manhattan puts genomic position against it. Both are scatters, so the navigation, the pitch and the braille all transfer -- and both are read almost entirely through a threshold, which is what a scatter has no notion of.

    Point-by-point navigation is not a viable path here. These charts routinely carry tens of thousands of points of which a few dozen matter. A reader who has to walk them has not been given access to the chart; they have been given a very long list. So two things carry the weight:

    The summary on entry. "43 of 12,000 points above the significance threshold" is the first thing a sighted reader takes from the shape of the cloud, and the last thing a per-point reading would ever assemble.

    A rotor filter over the points that clear it, so the few dozen that matter are reachable in a few dozen keystrokes rather than twelve thousand.

    Identity is the payload. A reader told "x is 2.3, y is 14.1" has been given the two numbers the axes already describe and withheld the one thing they came for, which is which gene that is. The label travels as an aside, so it survives every one of the scatter's navigation modes and is never run through an axis formatter -- a gene name is not a value on an axis.

    The threshold is declared, never guessed. These charts sit on transformed axes whose conventions differ by field and by tool: -log10(p) at 1.3 for p < 0.05, at 7.3 for genome-wide significance, and a raw p axis runs the other way entirely. A guessed line would sort every point on the figure onto the wrong side of it, silently. A layer that declares none gets the scatter's reading and no claim about significance.

    Hierarchy (View Summary)

    Index

    Constructors

    Properties

    Accessors

    Methods

    Constructors

    Properties

    observers: Observer<TraceState>[]
    isWarning: boolean
    isComputingStateAt: boolean

    True while AbstractTrace.getStateAt computes state at a temporarily moved cursor. Enforces (structurally, not just by documentation) that state getters never notify observers.

    id: string
    type: TraceType
    title: string
    name: string | undefined

    What this layer is, when the producer named it. See MaidrLayer.name.

    layer: MaidrLayer
    movable: MovablePlane
    supportsExtrema: true

    ] and [ go to the highest and the lowest point, and the Go To dialog lists them: see ScatterTrace.getExtremaTargets.

    highlightCenters:
        | {
            x: number;
            y: number;
            row: number;
            col: number;
            element: SVGElement;
        }[]
        | null
    flatPoints: FlatPoint[]

    Protected so a subclass can read the points themselves. A volcano plot needs each point's identity and whether it clears a threshold, neither of which is a coordinate.

    readingOrder: number[]
    readingPos: number[]

    Protected alongside readingOrder: it is the precomputed inverse of it, and a subclass filtering the reading order needs O(1) position lookups rather than a linear scan per keystroke.

    isInPointMode: boolean
    pointModeIndex: number

    Accessors

    • get isInitialEntry(): boolean

      Returns boolean

    • set isInitialEntry(value: boolean): void

      Parameters

      • value: boolean

      Returns void

    • get row(): number

      Returns number

    • set row(value: number): void

      Parameters

      • value: number

      Returns void

    • get col(): number

      Returns number

    • set col(value: number): void

      Parameters

      • value: number

      Returns void

    • get categoriesRunDown(): boolean

      Whether this trace's grid lists its categories as columns while the chart draws them one above another: a horizontal bar, dot, lollipop, funnel, dumbbell or forest chart. Its arrow keys are then turned to follow the drawing (keyDirection), as a horizontal box plot's already were: Up and Down move between the categories, and Left and Right along one, between the series, ends or sections drawn across it.

      Returns boolean

      False here; true on the traces of that shape drawn on their side

    • get xAxis(): string

      The x axis's name, falling back to a generic one the layer authored none.

      A getter rather than a field set in the constructor: the fallback is a translated word, and a trace outlives a language change — a name resolved once at construction would keep the language the chart was built in.

      Returns string

    • get yAxis(): string

      The y axis's name, or a generic one. See xAxis.

      Returns string

    • get z(): string

      The z axis's name, or a generic one. See xAxis.

      Returns string

    • get isEmptyAtCursor(): boolean

      Whether the cursor has no point to report.

      Read from dimension rather than from any one trace's data, because that is the one shape every trace already answers in. It is also evaluated at the cursor — LineTrace returns the current series' length as cols — so this covers a ragged layer, where one series has points and another has none, and not only a layer that is empty throughout.

      Returns boolean

      True when there is nothing at (row, col) to describe

    • get state(): TraceState

      Gets the current state of the trace including audio, braille, text, and highlight information.

      Returns TraceState

      The current TraceState

    • get layerLabel(): string

      How this layer names itself in the description dialog's layer tabs.

      The producer's name when there is one, and the chart-type label otherwise — the same fallback order TextService.layerIdentity uses for the spoken layer-switch announcement, so a tab and the announcement single out the same layer by the same name. The two differ only in register: the announcement says "point plot" where the dialog says "Scatter Plot", because that written form is what the dialog's own Chart Type line has always shown and a tab sitting above it should agree with it.

      Returns string

    • get placeAxisLabel(): string

      Returns string

      Trace.placeAxisLabel

    • get guide(): ChartGuide | undefined

      A plain-language introduction to this layer's chart type, for the description dialog. See chartGuide.

      A layer that names its own chart type never gets the trace type's: that guide explains the type the chart is read as, which is not what the chart is, and a gantt's tasks, dates and project plans said of a packet's bit fields are false. It gets the guide to the diagram it names (MaidrLayer.diagramType), or the one it gives to its own chart (MaidrLayer.typeGuide), or none.

      Returns ChartGuide | undefined

    • get orientationLabel(): string | undefined

      Which way this chart is drawn, or undefined for a type that has no orientation to speak of.

      Entering the chart already announces it -- "This is a maidr plot of type: horizontal bar" -- but the description dialog said only "Chart Type: Bar Chart", and for the box, violin and boxen families the orientation also silently reverses the order of the rows in the table underneath, because their constructors reverse the groups when the chart is horizontal. A reader comparing the table with what they walked had no way to know why the two disagreed.

      Exposed here, and read once by the description service, rather than pushed as a stat by each of the thirty-odd traces that has one. Named apart from the bar and distribution families' own orientation fields, which hold the declared* value and default it to vertical for every type -- including the ones that have no orientation at all.

      Returns string | undefined

      horizontal or vertical, or undefined when the type has no orientation to report.

    • get traceType(): TraceType

      The trace's chart type. Lightweight alternative to reading state.traceType, which eagerly computes the full audio/braille/text/ highlight state just to expose this one string.

      Returns TraceType

    • get level(): "trace"

      Returns "trace"

      Trace.level

    • get highlightValues(): SVGElement[][] | null

      Returns the appropriate highlight elements based on current navigation mode.

      Returns SVGElement[][] | null

      SVG elements for X-based or Y-based highlighting depending on mode

    • get values(): number[][]

      Returns number[][]

    • get highlightedPointIndices(): readonly number[]

      The points the highlight currently covers, as indices into this layer's data array.

      This is highlight answered in a renderer-neutral currency. highlight resolves the same five navigation modes into SVGElements, which a canvas chart has none of — so a canvas adapter is handed back an index into the data array it supplied, and inverts it against its own extraction walk. That keeps the binning here, in the model that owns it: the adapter never learns what a grid cell or an x-bucket is.

      Deliberately not gated on SVG availability, where highlight falls back to out-of-bounds when the binder supplied no elements. A canvas chart has no elements by definition, and that is exactly the case this exists to serve.

      Returns an empty array when nothing is addressed, which a consumer reads as "clear the overlay".

      Returns readonly number[]

      Indices into layer.data, in no particular order.

    • get hasMultiPoints(): boolean

      Returns boolean

    • get outOfBoundsState(): TraceEmptyState

      Returns out-of-bounds state with the position the active navigation mode is actually on, so the boundary chime pans from where the user is.

      Grid, point and intersection mode each keep their own cursor; the base implementation pans by row/col, which in those modes is the stale cursor from before the mode was entered.

      Returns TraceEmptyState

    • get valueSpan(): number

      The range of the y values, which ] and [ rank the points by. The layer's values hold its x values beside them, and reading them moves the cursor's row back into bounds.

      Returns number

      The y range, never negative

    Methods

    • Runs action with this element's observers muted.

      A cursor move normally is the announcement -- moveToIndex notifies, and everything downstream of it speaks, brailles and highlights. That is wrong for a move the reader did not make and is not waiting to hear: the description dialog's layer tabs relocate the reader in the chart while the modal is open, and the trace's announcement would land in the same live region the dialog is using, so one of the two is dropped. The caller announces afterwards, once, when the reader is back on the chart.

      Nesting is safe and the flag is restored on every path, including a throw, because a flag left raised would silence the chart for good.

      Parameters

      • action: () => void

        The moves to make in silence

      Returns void

    • Gets safe row and column indices to prevent accessing undefined values

      Returns { row: number; col: number }

      Object with safe row and column indices

    • The rotor's LOWER and HIGHER VALUE search. The base is a no-op that reports the boundary: a trace that can compare overrides it, and supportsCompareMode offers the two modes exactly where it does.

      Parameters

      • _direction: "left" | "right" | "up" | "down"
      • _type: "lower" | "higher"

      Returns boolean

    • Parameters

      • a: number

        Utility function to compare point values for rotor functionality

      • b: number
      • type: "lower" | "higher"

      Returns boolean

      boolean value

    • Rotor compare search along one row of numeric values.

      Steps from the current column in the given direction and moves to the first value that satisfies the comparison; reports the rotor boundary when nothing further qualifies. For the traces whose values are a plain numeric grid indexed [row][col]; a trace with a richer layout (the bar's orientation-normalised rows, the candlestick's segments) keeps its own.

      Parameters

      • rowValues: readonly number[]

        The values of the row being searched

      • direction: "left" | "right"

        Which way to search

      • type: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      True when a matching value was found and moved to

    • The rotor's lower and higher value search, Up: on a chart drawn on its side, along the categories toward the one drawn above, as Up moves. Elsewhere the rotor reads Up as Right.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved

    • The rotor's search, Down: toward the category drawn below. See moveUpRotor.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved

    • The rotor, Left: on a chart drawn on its side, the plain move along the category, as a horizontal box plot's rotor moves along its box. The search runs along the categories, which Up and Down walk there.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved. False at the end of the category -- on a chart of one series, always -- so the rotor says there is nothing further that way; it reported true, and the rotor said nothing.

    • The rotor, Right. See moveLeftRotor.

      Parameters

      • Optionalmode: "lower" | "higher"

        Whether a lower or a higher value is sought

      Returns boolean

      Whether the cursor moved, false at the end of the category

    • The direction to move the grid for a key, which is the key's own except on a trace whose categories run down the page. There the grid's columns are drawn one above another and its rows across them, so Up and Down step the columns, toward the category drawn above or below, and Right and Left step the rows. On a horizontal bar chart Right and Left moved down and up the page between the bars, and Up and Down said there was no more data: the other way round from a horizontal box plot or violin.

      Parameters

      Returns MovableDirection

      The direction to move the grid in

    • Whether the first category is drawn above the last.

      Producers list a horizontal chart's categories both ways: matplotlib, ggplot2, base R and Plotly draw the first at the bottom, and Highcharts, ApexCharts, Vega-Lite, seaborn and most hand-drawn charts at the top. So it is measured, as a Gantt chart measures its lanes, from the marks the highlight holds: in the first row that has two, the first category's mark is above the last one's, or below it. Measured on every vertical key, an autoplay step included, rather than once. That is two boxes a key, however many categories the chart has: the two marks are found from the ends of the row, and the read forces at most the layout the highlight's move would cause before the next paint. An answer kept from the first key was kept from a chart not yet laid out, or one since re-rendered the other way round, and a cache would have to be cleared on every redraw and resize to avoid that.

      Where nothing can be measured now, the last measurement holds, so a chart hidden for a moment does not turn the keys round under the reader. Where nothing has ever been measured -- a chart drawn to a canvas, one with no highlight, one not laid out yet, or one category -- the layer's MaidrLayer.firstCategory says where the first is drawn. Without it, the first is taken to be at the bottom, as row 0 of a grid is, and Up moves to the next.

      Returns boolean

      True when the first category is drawn at the top

    • The format the layer's author declared for an axis, or null when they declared none.

      For a number the description states rather than tabulates. The table reads each column through the axis's declared format, and so does every announcement, but a stat printed the raw number: a margin drawn as a percentage was "Min value: 0.12" over a table and a cursor saying 12%. Null rather than the default format when nothing was declared, so a chart nobody formatted reads as it did, which is the rule the table follows.

      Taken from FormatUtil.axisFormat, as the announcements and the table take theirs, so a histogram's bin edges read with the same decimals in all three.

      Parameters

      • axis: AxisType

        The axis whose format to read

      Returns FormatFunction | null

      The format, or null when the layer declared none

    • Get all highlight SVG elements for this trace Used by HighlightService for high contrast mode

      Returns SVGElement[]

      Array of all SVG elements, or empty array if none

    • The chart's own element a marker this trace drew stands for, where the trace marks a point with a dot of its own rather than with a copy of the mark. None by default.

      Parameters

      • _marker: SVGElement

        A marker in this trace's highlight values

      Returns SVGElement | null

      The element the marker stands for, or null

    • Get all original (visible) SVG elements for this trace. These are the actual rendered elements, not the hidden clones used for highlighting. Used by HighlightService for high contrast mode color changes.

      Returns SVGElement[]

      Array of all original SVG elements, or empty array if none

    • Returns a human-readable label for this trace's chart type (e.g., 'Bar Chart', 'Scatter Plot') for display in the description modal. Falls back to the raw layer type if no mapping is registered.

      Returns string

    • What the entry instruction calls this chart: the name the layer gives its own chart type (MaidrLayer.diagramType or MaidrLayer.typeLabel), or the trace's word.

      A trace that names itself -- a line "single line" or "multiline", a radar "polar area" -- passes its word through here, so a layer that names its chart type is called by that name whichever trace reads it, and the instruction a reader hears once in the chart says what the one built from the layer before it said.

      Parameters

      • own: string

        The trace's word for its type

      Returns string

      The word the instruction uses

    • Builds the axes object for the description state, carrying only the axes the layer actually authored a label for. Subclasses should call this instead of constructing the axes object inline so charts without a real z dimension don't surface the placeholder default.

      Every axis is gated, not just z. xAxis and yAxis fall back to the literal 'X' and 'Y' when the JSON authors no label -- legal, and common in adapter-generated specs -- and the dialog rendered that as "X: X", a line that says nothing twice. The figure-level branch of the description already showed only authored labels (DescriptionService.getFigureAxes), so gating here is what makes the two levels of the same dialog follow one rule.

      Blankness is tested with trim(), the same rule named applies when it decides whether to substitute the fallback in the first place. A whitespace-only z label is truthy but blank, so the untrimmed guard used to pass it through and then print the 'Level' placeholder the guard existed to keep out.

      Returns { x?: string; y?: string; z?: string }

    • Notifies the trace which of its getRotorFilterUnits the rotor is on, or null when it is on none of them. Default is a no-op: a unit usually changes only where Left and Right go, which moveToRotorFilter answers. A trace whose unit also changes what Control with them should reach -- a tree's Level, where Left and Right walk the whole level -- overrides this, because the jump is not routed through the rotor.

      Parameters

      Returns void

    • Every object the o list offers on this chart, or null where there is none to offer.

      Null for every chart walked along x and y axes: the arrows already reach each point in order there, and a list of them would repeat the axis. A chart whose objects have no such order -- the nodes of a network, the tiles of a treemap -- overrides this and builds the list from its own structure, with the sorts and filters that make sense for it.

      List only, as the rotor units are, with no flag beside it: a flag that said yes over an empty list would open a dialog with nothing to choose. Labels are built on each call, because the trace outlives a change of language; anything expensive to compute is kept by the trace that computes it.

      Returns ChartObjectList | null

      The list, or null

    • Moves to the object the list knows by this key, announcing it through the usual observer chain.

      Looks the key up in a list built now rather than trusting a cell the dialog was handed when it opened, so a chart whose data changed under the dialog moves the reader to the object they chose or nowhere at all.

      Parameters

      • key: string

        The key the object list gave the object

      Returns boolean

      True when the cursor moved, false when no object has the key or its cell cannot be reached

    • How this layer's x axis writes an x: through the format the layer declares for it, or null where it declares none.

      A layer switch carries a number this way to a layer that holds the same place as text (see Subplot.carriedXValue).

      Parameters

      • xValue: XValue

        An x of this layer's

      Returns string | null

      Its reading, or null

    • Moves the active point to the pointer location and returns directional guidance toward the nearest data geometry in a single call.

      Combining both operations avoids running findNearestPoint twice per pointermove event — important on dense plots where the scan is the hot path.

      Parameters

      • x: number

        Screen-space x position of the pointer/finger

      • y: number

        Screen-space y position of the pointer/finger

      Returns PointerGuidanceState | null

      Guidance state relative to nearest point, or null when unavailable

    • Checks if the specified coordinates are within bounds of the element.

      Parameters

      • x: number

        The x-coordinate

      • y: number

        The y-coordinate

      • element: NearestPoint

        Object containing the SVG element and its position

        • element: SVGElement
        • row: number
        • col: number
        • centerX: number
        • centerY: number

      Returns boolean

      True if the point is in bounds, false otherwise

    • Returns an empty object to avoid grouping scatter points by audio tone.

      Returns { groupIndex?: number }

      Empty object without groupIndex to maintain consistent audio feedback

    • Where one of this layer's data points sits in the trace's own coordinates — the inverse of ScatterTrace.highlightedPointIndices.

      A scatter does not navigate its points in the order they arrived: the constructor sorts by x and groups the duplicates, so a column is one unique x. A raw data index read as a column therefore names a different point, or none at all once duplicates have collapsed several into one. That is what a streamed point needs translating out of before it can be announced (LiveDataManager.appendData reports the new point by data index).

      Mode-aware, because the coordinate the state getters read is: COL announces the column at col and pans by the point's place within it, ROW announces the row at row.

      Parameters

      • index: number

        An index into this layer's data array

      Returns { row: number; col: number } | null

      The position to read that point at, or null when the index is not one this trace has

    • The x the reader is at, in terms of the axis they are walking.

      COL mode walks the x values, so it is the column's x. ROW mode walks the y values, so the x reported is the one the reader would land on when switching back to columns (the same middle-of-the-row rule toggleNavigation applies), which keeps a layer switch near the points they were hearing. The inherited reading of values[row][col] over [xValues, yValues] answered with a y value at row 1 and with nothing at all above it.

      Returns XValue | null

      The current x, or null when the cursor is off the data

    • The name of the point the reader is on, as its announcement gives it, or null where the cursor is on no one named point.

      Another layer of the chart may draw the same things by name rather than by place: the value chain of a Wardley map is a graph of the very components the map places. Offered as a second X, it lets a layer switch land on the same component where the evolution, a number, matched no node and put the reader on the first.

      A column or a row of several points names none of them, and is offered by the name of the one point navigation would start on, the first in reading order: two components at one evolution are both the reader's, and the layer entered draws each of them, where the evolution matched neither and put the reader on its first node.

      Returns XValue | null

      The point's name, or null

    • Whether a column carries this name, or a point is called it.

      A layer switch asks this of a name another layer offers (see getAlternateXValue). A number is not answered, as before: a numeric x is matched to the nearest column whatever it is.

      Parameters

      • xValue: XValue

        The x a layer switch would carry

      Returns boolean

      True when moveToXValue would find it by name

    • The column x that the x axis writes as reading, or null where the layer declares no x format or no column's x reads that way.

      The points are kept by column here rather than in points, which the inherited lookup reads. A line over a time column holds its x as the text the scatter's time format writes, and a layer switch from it finds the scatter's point this way (#1717).

      Parameters

      • reading: string

        The text another layer holds the place as

      Returns XValue | null

      The x, or null

    • Moves to the column at an x value, entering COL mode to do so.

      An exact x wins; a numeric x with no exact column falls back to the nearest one, as the shared helper does for other traces, and a categorical x is matched against the column labels, then against the names of the points. A point found by its name in a column it shares is landed on by its row instead, where that names it (see rowNaming).

      Parameters

      • xValue: XValue

        The x to move to

      Returns boolean

      True when a column was found and the cursor moved

    • Enters or leaves grid navigation.

      Entry starts in the cell holding the point the reader is on -- the one they reached in point navigation when they come straight from it, else the one setPointMode would start on -- so the first arrow moves from where they are, and the point still outlined lies in the cell the cursor is on. Before the reader has entered the data, or when that point lies outside the grid, it starts in the bottom-left cell. Always starting there put the cursor in a cell the reader was not in, unannounced, with their own point still outlined elsewhere.

      Parameters

      • enabled: boolean

        Whether grid navigation is on

      Returns void

    • Notifies the observers of the reader's new place. Whatever they hear now, they are no longer on the point they left point navigation on.

      Returns void

    • Whether the rotor offers its lower and higher value modes on this trace.

      Exactly when the trace overrides moveToNextCompareValue. The base search is a no-op that reports a boundary, so offering the modes without one told a reader "No lower value found" with a lower value beside them, or said nothing at all; tying the offer to the search keeps the two from drifting apart again. A subclass can still override this to withhold the modes (scatter, whose arrows walk points rather than values), and a trace that compares only through the rotor's arrow methods must override it to offer them.

      Returns boolean

    • Returns the display name for the default data navigation mode. Override to provide a trace-specific name (e.g., "ROW AND COLUMN NAVIGATION" for scatter).

      Returns string

    • Enters grid cell mode to navigate points within the current cell. Groups cell points by X coordinate (like COL mode) for navigation.

      Returns boolean

      true if entered successfully, false if no points in cell

    • Mirrors LineTrace's intersection rule: the mode is offered only when navigating across the data is meaningful. For scatter, that means a stack exists on either axis — either an x with multiple ys (column stack) or a y with multiple xs (row stack). Either base mode (COL / ROW) can enter the rotor and cycle through its corresponding stack, so the capability check is the OR of both.

      Returns boolean

    • Called by the rotor service when entering / leaving INTERSECTION_MODE. Preserve the active NavMode: entering from COL cycles through the y-stack at the current x; entering from ROW cycles through the x-stack at the current y. Force-switching modes here would silently re-anchor the user on a different point set — the bug fixed by this commit.

      No notifyStateUpdate(): mirrors setPointMode and setGridMode; the rotor announces the mode name and the next arrow press emits the focused state.

      Parameters

      • enabled: boolean

      Returns void

    • Why [, ] and G have nothing to go to in grid and intersecting point navigation: the one moves between cells rather than points, and the other only among the points at the same x or y, so neither has a point of the whole plot to go to.

      Returns string | null

      The reason in those two modes, null in the others

    • Walks one step forward through the current stack — y values at the current x in COL mode, x values at the current y in ROW mode. Returns false at the top of the stack so the rotor can announce the boundary; no chime (consistent with LineTrace's intersection bounds).

      Returns boolean

    • Returns true if this trace supports point-by-point navigation mode. Opt-in per trace type: override to return true for traces that expose individual data points navigable in reading order (left/right) and column-major order (up/down). Currently only ScatterTrace.

      Returns boolean

    • Enters or exits point-by-point navigation mode.

      On entry, the current point is seeded from whatever ROW_COL position the user was on so they keep their place in the data. When the previous mode highlighted a group of points (e.g. a column of points sharing an x in COL mode), we pick the first point in reading order from that group — highest y for COL mode, lowest x for ROW mode.

      On exit, no state needs to be unwound; the existing row/col indices are untouched while in point mode, so ROW_COL navigation resumes where it left off. The point the reader was on is kept until they hear another, so grid navigation entered next starts in its cell (see setGridMode).

      Parameters

      • enabled: boolean

      Returns void

    • Converts SVG elements to center coordinates for proximity-based navigation.

      Returns { x: number; y: number; row: number; col: number; element: SVGElement }[] | null

      Array of center points with coordinates and indices, or null if unavailable

    • Finds the nearest scatter point to the given screen coordinates.

      Parameters

      • _x: number

        The x-coordinate in screen space

      • _y: number

        The y-coordinate in screen space

      Returns NearestPoint | null

      The nearest point with its element and indices, or null if unavailable

    • Reads state at an explicit cursor, with the trace-local navigation modes suspended for the duration.

      getStateAt moves row/col and reads the state getters, but point, intersection and grid mode short-circuit those getters onto their own cursor — so a live-appended point would be announced as whichever point or cell the user happens to be focused on. Suspending the flags makes the read positional again, which is what every caller of this method asks for.

      Parameters

      • row: number

        Row index to read at

      • col: number

        Column index to read at

      Returns TraceState

      The trace state at that position

    • Moves the trace to the nearest point when the pointer is within its bounds and the trace is not already focused on that point.

      onCurve is intentionally non-optional: the caller has already paid the cost of isPointInBounds to assemble guidance state, and forcing subclasses to accept the value makes the contract explicit so a future override cannot silently recompute (or worse, ignore) it.

      Subclasses override this to customise hover-driven navigation:

      • Box / ViolinBox no-op the move while still surfacing guidance.
      • Scatter switches into column navigation mode before delegating.

      Parameters

      Returns void

    • The highest and the lowest points, for ], [ and the Go To dialog: the largest and the smallest y, what the pitch plays.

      Walking columns and rows, each is the row of points at that y, where Control + Up and Control + Down go from a column; one row holds every point at its y, so it is one target, unless another row's y is within a billionth of the plot's y range of it, which is the same extreme. In point navigation each is a point, and every point holding the extreme is offered in reading order, so a tie is walked. Grid and intersection navigation offer none: their cursors are a cell and a stack of points rather than a point.

      Returns ExtremaTarget[]

      The targets, or none in grid or intersection navigation or for a plot with no measured y

    • Offers the significant points when the chart declares a threshold.

      Withheld when no threshold is declared -- there is nothing to filter on -- and withheld when one is declared but nothing clears it, since a mode whose only possible answer is "none found" is worse than not offering it. That second case is a real reading of the chart, and the description says so in words.

      Returns readonly RotorFilterUnit[]

      The significant unit alongside whatever the scatter offers

    • Moves within an active rotor filter unit along the filtered axis.

      Called by RotorNavigationService when the current rotor mode is one of this trace's getRotorFilterUnits. Filter units navigate a single axis, so only left/right are dispatched here — the service announces up/down as unavailable without calling the model (matching intersection mode). Implementations should move to the nearest point matching the unit identified by key and notify observers, returning true; when no such point exists they should call notifyRotorBounds and return false.

      Default is a no-op that reports bounds, so a trace advertising a filter unit but forgetting to implement movement fails safe (announces "no point found") rather than moving unexpectedly.

      Parameters

      • key: string
      • direction: "left" | "right"

      Returns boolean

      True if the cursor moved, false otherwise