@aceshooting/lyra-ui 4.2.0 → 5.1.0

package/dist/components/graph/graph.class.d.ts

@@ -1,675 +0,0 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import '../skeleton/skeleton.class.js';
-export interface GraphNode {
-    id: string;
-    label?: string;
-    /** Spoken label when it needs more context than the visible label. */
-    accessibleLabel?: string;
-    /** Optional native SVG tooltip text. */
-    description?: string;
-    /** Clamped to [6, 24] (a non-finite/missing value uses the midpoint, 15) — never rendered smaller/larger. */
-    radius?: number;
-    color?: string;
-    /** Key into `nodeTypes` (by `GraphNodeType.id`) and `hiddenTypes`. Unknown/absent = untyped
-     *  (renders as a default circle with the token fill, but still participates in `hiddenTypes`
-     *  filtering by its raw string value even with no matching `nodeTypes` entry). */
-    type?: string;
-    /** Renders a "+" adornment (`part="expand-indicator"`) and marks the node expandable in spoken
-     *  text via `graphExpandableItem`. Controlled -- the component never clears this on its own; a
-     *  consumer flips it (or leaves it) after appending neighbors in response to a `lr-node-expand`.
-     *  Does not gate the `lr-node-expand` event itself, which fires for any node's double-activate. */
-    expandable?: boolean;
-    /** Community membership shorthand, unioned with any `GraphCommunity.memberIds` that also lists
-     *  this node's id. */
-    communityId?: string;
-}
-/** One entry in `nodeTypes` — declares a node type's legend label, optional fill color (sanitized
- *  like `GraphNode.color`), and rendered shape. */
-export interface GraphNodeType {
-    id: string;
-    label: string;
-    color?: string;
-    shape?: 'circle' | 'square' | 'diamond';
-}
-/** One entry in `communities` — declares a hull's id, optional label/fill color (sanitized like
- *  `GraphNode.color`), and explicit membership. A node also joins this hull when its own
- *  `GraphNode.communityId` matches this entry's `id`, so `memberIds` and `communityId` are two
- *  ways to express the same membership relationship. */
-export interface GraphCommunity {
-    id: string;
-    label?: string;
-    memberIds: string[];
-    color?: string;
-}
-/** A link whose `target` id has no matching node renders as a short dashed stub off `source`'s
- *  own position instead of being silently dropped -- e.g. for a wiki-style `[[link]]` reference to
- *  a not-yet-created page. A link whose `source` id has no matching node is still dropped
- *  entirely (there is no position to draw a stub from). */
-export interface GraphLink {
-    /** Optional stable id returned by `lr-link-click`. */
-    id?: string;
-    source: string;
-    target: string;
-    width?: number;
-    /** Optional spoken-name and SVG-tooltip fallback used before the generated source/target text.
-     * It is not rendered as a visible edge label. */
-    label?: string;
-    /** Spoken label for the keyboard-operable link. */
-    accessibleLabel?: string;
-    /** Optional native SVG tooltip text. */
-    description?: string;
-    /** Draw an arrowhead at the target end. */
-    directed?: boolean;
-    /** Per-link stroke color; unsafe CSS declaration delimiters are rejected. */
-    color?: string;
-    /** SVG stroke-dash sequence. Invalid/negative entries are rejected as a whole. */
-    dash?: number[];
-}
-export interface LyraGraphEventMap {
-    'lr-node-click': CustomEvent<{
-        id: string;
-        x: number;
-        y: number;
-    }>;
-    'lr-link-click': CustomEvent<{
-        source: string;
-        target: string;
-        id?: string;
-    }>;
-    'lr-node-enter': CustomEvent<{
-        id: string;
-    }>;
-    'lr-node-leave': CustomEvent<{
-        id: string;
-    }>;
-    'lr-link-enter': CustomEvent<{
-        source: string;
-        target: string;
-        id?: string;
-    }>;
-    'lr-link-leave': CustomEvent<{
-        source: string;
-        target: string;
-        id?: string;
-    }>;
-    'lr-node-expand': CustomEvent<{
-        id: string;
-    }>;
-    'lr-selection-change': CustomEvent<{
-        nodeIds: string[];
-        linkIds: string[];
-    }>;
-    'lr-community-click': CustomEvent<{
-        id: string;
-    }>;
-}
-/**
- * `<lr-graph>` — a force-directed node-link diagram with pan/zoom/drag.
- * Requires the optional peer deps `d3-force`/`d3-drag`/`d3-zoom`/`d3-selection`
- * (lazy-loaded; a consumer who never uses this component pays zero d3 cost).
- *
- * Set `seed` for a deterministic layout: node initial positions become
- * reproducible (keyed by node id) and the settle happens synchronously
- * instead of animating, like `prefers-reduced-motion`. `seed` only takes
- * effect on the update that first populates `nodes`/`links` (or a later
- * update that adds genuinely new node ids) — willUpdate() only reads it from
- * inside rebuildSimulation(), which itself only ever assigns x/y to nodes
- * that don't already have a settled position, so changing `seed` on an
- * already-rendered graph is a no-op; nothing re-derives already-positioned
- * nodes' x/y from the new value.
- *
- * `hiddenTypes` filters nodes/links by `GraphNode.type` without discarding position state --
- * `lastPositionById` remembers every node's last settled x/y across a hide/show round-trip, so
- * toggling a type off and back on restores each node where it was instead of re-randomizing it.
- *
- * `communities` draws one translucent convex-hull blob per entry, behind links/nodes -- a hull's
- * membership is the union of its own `memberIds` and every node whose `communityId` matches its
- * `id`. A community with no currently-visible members (all its nodes hidden by `hiddenTypes`, or
- * simply empty) renders no hull.
- *
- * `layout="layered"` swaps the d3-force simulation for a deterministic layered layout (see
- * `src/internal/layered-layout.ts`) -- node drag is disabled in that mode, and `chargeStrength` is
- * a documented no-op.
- *
- * `renderer="canvas"` swaps the per-node/per-link SVG DOM for a single DPR-aware `<canvas>` --
- * every event/method/property behaves identically to `renderer="svg"` (the default), with hit-
- * testing resolved via an offscreen color-picking canvas instead of DOM event targets. The
- * documented trade-offs: no `::part(node)`/`::part(link)` styling (pixels, not elements -- theme
- * via cssprops instead), no native SVG `<title>` tooltip (replaced by `part="tooltip"`), and a
- * drawn focus ring instead of a CSS one. Keyboard roving/announcements are preserved through an
- * offscreen `part="cursor-item"` button per node/link/hull, driving the identical roving-tabindex
- * logic as `renderer="svg"`.
- *
- * @customElement lr-graph
- * @event lr-node-click - `detail: { id, x, y }`, where `x` and `y` are the
- *   node's current coordinates in the graph's local drawing space.
- * @event lr-link-click - `detail: { source, target, id? }`.
- * @event lr-node-enter - A node was hovered. `detail: { id }`. Suppressed while dragging or
- *   panning. Also toggles a `data-hovered` attribute on that node's `[part="node"]` element for
- *   pure-CSS theming (not a substitute for this event — a consumer computing its own
- *   adjacency-based highlight needs the id, which only the event carries).
- * @event lr-node-leave - The hover from `lr-node-enter` ended. `detail: { id }`.
- * @event lr-link-enter - A link was hovered. `detail: { source, target, id? }`. Same
- *   suppression/`data-hovered` behavior as `lr-node-enter`.
- * @event lr-link-leave - The hover from `lr-link-enter` ended. `detail: { source, target, id?
- *   }`.
- * @event lr-node-expand - A node was double-activated (native `dblclick`, or two Enter/Space
- *   activations of the same focused node within 500ms). `detail: { id }`. Fires for any node
- *   regardless of `GraphNode.expandable` -- that flag only controls the visual "+" affordance and
- *   spoken "expandable" suffix.
- * @event lr-selection-change - `detail: { nodeIds, linkIds }`. Fires when `selectionMode` is not
- *   `'none'` and the user activates/clears a node or link. The component never assigns
- *   `selectedNodeIds`/`selectedLinkIds` itself -- controlled, mirroring `lr-heatmap.selectedCell`.
- * @event lr-community-click - A hull was activated. `detail: { id }`.
- * @csspart base - The graph wrapper.
- * @csspart svg - The graph SVG.
- * @csspart node - A graph node.
- * @csspart link - A graph link.
- * @csspart arrowhead - The marker used by directed graph links.
- * @csspart label - A node label.
- * @csspart link-label - A drawn edge label (only rendered when `showEdgeLabels` is set).
- * @csspart expand-indicator - The "+" badge rendered on a node with `expandable: true`.
- * @csspart focus-halo - The persistent ring tracking `focusId`'s node.
- * @csspart hull - A community hull (behind links/nodes; role="button").
- * @csspart community-label - A hull's label text.
- * @csspart live-region - The current graph item announcement.
- * @csspart data-list - A visually hidden list alternative for graph data.
- * @csspart empty - The empty-state message, shown when `nodes` is empty.
- * @csspart canvas - The single canvas surface (`renderer="canvas"` only).
- * @csspart tooltip - The hover tooltip (`renderer="canvas"` only; the SVG `<title>` replacement).
- * @csspart cursor-items - The container of offscreen keyboard-roving items (`renderer="canvas"` only).
- * @csspart cursor-item - An offscreen keyboard-roving item (`renderer="canvas"`'s a11y virtual cursor).
- * @cssprop [--lr-node-fill=var(--lr-color-brand)] - Default node fill, overridden per-node by `GraphNode.color`.
- * @cssprop [--lr-link-color=var(--lr-color-border)] - Default link stroke, overridden per-link by a link's own `color`.
- * @cssprop [--lr-graph-cat-1..8] - Ordered categorical fallback palette for a typed node with no
- *   `GraphNodeType.color`, assigned by the type's index in `nodeTypes` (wraps every 8 entries).
- *   Declared centrally in `tokens.styles.ts` so `<lr-graph>` and any future `<lr-graph-legend>`-
- *   style component resolve the identical default.
- * @cssprop [--lr-graph-edge-label-halo=var(--lr-color-surface)] - Legibility halo (`stroke`)
- *   behind a drawn edge label, painted under the fill via `paint-order: stroke`.
- * @cssprop [--lr-graph-focus-halo-color=var(--lr-color-brand)] - `focus-halo` stroke color.
- * @cssprop [--lr-graph-selected-color=var(--lr-color-success)] - Selected node/link stroke.
- * @cssprop [--lr-graph-dimmed-opacity=1] - Opacity applied to a node/link when
- *   `dimmedNodeIds`/`dimmedLinkIds` includes its id (both SVG and canvas renderers). `1` (the
- *   default) is a no-op -- an unset host sees no visual change.
- * @cssprop [--lr-graph-hull-fill=var(--lr-color-brand)] - Hull fill/stroke color.
- * @cssprop [--lr-graph-hull-opacity=0.12] - Hull element opacity (composites fill+stroke as one
- *   group, avoiding a double-opacity seam at the fill/stroke boundary).
- */
-export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
-    static styles: import("lit").CSSResultGroup[];
-    nodes: GraphNode[];
-    links: GraphLink[];
-    /** Declares each `GraphNode.type` value's legend label, fill color, and shape. A typed node with
-     *  no matching entry here renders as untyped (default circle, token fill) but still participates
-     *  in `hiddenTypes` filtering by its raw `type` string. */
-    nodeTypes: GraphNodeType[];
-    /** Hides every node whose raw `type` value is listed here (no matching `nodeTypes` entry
-     *  required), plus every link incident to a hidden node -- removed from the render, the
-     *  simulation input, the keyboard roving ring, the sr-only data list, and the accessible
-     *  diagram counts, as if absent. Positions round-trip via `lastPositionById`: toggling a type
-     *  off and back on restores each node where it was. */
-    hiddenTypes: string[];
-    /** Renders one translucent hull per entry, behind links/nodes. Membership is the union of
-     *  `memberIds` and every node whose `communityId` matches this entry's `id`. */
-    communities: GraphCommunity[];
-    /** `'force'` (default) runs the existing d3-force simulation, untouched. `'layered'` computes a
-     *  deterministic Sugiyama-lite layout (`src/internal/layered-layout.ts`, a shared,
-     *  dependency-free util suitable for any future layered-diagram consumer) instead -- no settle
-     *  animation, node drag disabled (dragging would fight a computed layout), `chargeStrength` a
-     *  documented no-op, `linkDistance` retunes the layer gap. Switching at runtime repositions
-     *  without a tween. */
-    layout: 'force' | 'layered';
-    /** `'svg'` (default, unchanged) renders the existing per-node/per-link DOM. `'canvas'` swaps to
-     *  a single `<canvas part="canvas">` -- the scale path (an honest ceiling for `'svg'`: dozens to
-     *  low hundreds of nodes; `'canvas'` targets roughly 5,000 nodes / 10,000 links). Feature-reduced
-     *  by design: no `::part(node)`/`::part(link)` styling (pixels, not elements -- theme via
-     *  cssprops), no SVG `<title>`, a drawn focus ring instead of a CSS one. All events/methods/
-     *  props otherwise behave identically across renderers. Runtime changes tear down and rebuild
-     *  the surface; positions survive via `prevById`/`lastPositionById`. */
-    renderer: 'svg' | 'canvas';
-    width: number;
-    height: number;
-    chargeStrength: number;
-    linkDistance: number;
-    minZoom: number;
-    maxZoom: number;
-    /** Accessible name forwarded from the host to the semantic graph SVG. */
-    accessibleLabel: string | null;
-    /** When set, seeds each node's initial x/y deterministically (keyed by
-     *  node id, not array index) instead of forceSimulation()'s own random
-     *  start, and settles the simulation synchronously — see rebuildSimulation().
-     *  Only takes effect on the update that first assigns a given node id an
-     *  x/y (i.e. supplied at/before `nodes`/`links` first populate, or when a
-     *  later update introduces new node ids) — changing `seed` afterwards does
-     *  not retroactively reposition already-settled nodes; there is currently
-     *  no way to make an already-rendered graph reproducible after the fact. */
-    seed?: number;
-    /** Draws each resolved (non-dangling) link's `label` as visible SVG text at the segment
-     *  midpoint. Off by default — `GraphLink.label` stays spoken/tooltip-only, matching today's
-     *  behavior, unless this is set. */
-    showEdgeLabels: boolean;
-    /** Below this zoom scale, every drawn edge label is hidden (a `data-edge-labels-hidden`
-     *  attribute toggled on the zoomed `<g>`, no Lit re-render). Ignored when `showEdgeLabels` is
-     *  false. */
-    edgeLabelMinZoom: number;
-    /** Declaratively centers the camera on this node id once, the first time it resolves (on mount
-     *  or when the id first appears in `nodes`) -- does not re-center on later mutations, so it
-     *  can't fight a user's panning on a streaming graph. Renders a persistent halo
-     *  (`part="focus-halo"`) around the node while set. See `focusNode()` for the imperative twin. */
-    focusId: string | null;
-    /** `'none'` (default) preserves today's behavior exactly -- no `aria-pressed`/`data-selected`,
-     *  no `lr-selection-change`. Controlled, mirroring `lr-heatmap.selectedCell`: the component
-     *  never mutates `selectedNodeIds`/`selectedLinkIds` itself, only emits intent; the host assigns
-     *  them back. */
-    selectionMode: 'none' | 'single' | 'multiple';
-    selectedNodeIds: string[];
-    selectedLinkIds: string[];
-    /** Node ids to render dimmed (`data-dimmed` on the matching `[part="node"]`, themeable via
-     *  `--lr-graph-dimmed-opacity`). Controlled, mirroring `selectedNodeIds`/`selectedLinkIds`: the
-     *  component never assigns this itself, only renders it -- a host typically computes it from a
-     *  `lr-node-enter`/`lr-link-enter` hover (the complement of the hovered id's neighbor set,
-     *  computed from the host's own `links` array) and assigns the result back. Empty (the default)
-     *  renders every node at full opacity, unchanged from today. */
-    dimmedNodeIds: string[];
-    /** Same contract as `dimmedNodeIds`, for links. A link's dimming key is the same `linkKey()`
-     *  value (`GraphLink.id`, else `` `${source}->${target}` ``) `selectedLinkIds` already uses. */
-    dimmedLinkIds: string[];
-    private readonly arrowMarkerId;
-    /** True until the lazy-loaded d3 peer dependencies have settled (success or failure). */
-    private loading;
-    private simNodes;
-    private simLinks;
-    private danglingLinks;
-    /** Every node's last-known settled position, keyed by id, independent of current visibility --
-     *  consulted by `rebuildSimulation()` (after the existing carried-over-position map) so a
-     *  `hiddenTypes` toggle restores a node where it was instead of re-randomizing it. Pruned to ids
-     *  present in `this.nodes` (not just currently-visible ones) on every rebuild. */
-    private lastPositionById;
-    /** The `hiddenNodeCount` computed by the most recent `rebuildSimulation()` -- lets that method
-     *  tell "nothing has ever been hidden" (never touch `graphLiveText`, so a consumer that never
-     *  sets `hiddenTypes` keeps today's exact live-region output) apart from "a hide was just
-     *  cleared" (still announce the resulting "0 of N" count). */
-    private lastHiddenNodeCount;
-    /** One roving tab stop across all nodes and links; nodes are the initial entry order. */
-    private activeGraphItem;
-    private graphLiveText;
-    private simulation?;
-    /** The live charge/link force objects, kept so chargeStrength/linkDistance
-     *  changes can retune them in place (see updated()) instead of requiring a
-     *  full rebuildSimulation(). */
-    private chargeForce?;
-    private linkForce?;
-    private d3?;
-    /** The `<svg>` (or, in `renderer="canvas"` mode, the `<canvas>`) currently wired up with d3-zoom
-     *  (guards a one-time bind per element). */
-    private zoomedEl?;
-    /** The pan/zoom `<g>`, cached alongside `zoomedEl` so the zoom handler can
-     *  write the transform straight to the DOM (see applyInteractions()) instead
-     *  of round-tripping through a Lit reactive property on every pan/zoom event. */
-    private gEl?;
-    /** The live zoom behavior, kept so minZoom/maxZoom changes can retune its
-     *  scaleExtent in place (see applyInteractions()) instead of requiring the
-     *  `<svg>` to be rebound. */
-    private zoomBehavior?;
-    /** Node `<circle>`s already wired up with d3-drag; cleared on every simulation rebuild
-     *  so DOM elements Lit reuses across a rebuild get rebound to their fresh datum. */
-    private boundNodeEls;
-    /** Node/link/label DOM elements, index-aligned with simNodes/simLinks, cached
-     *  once per structural rebuild and written to directly by onTick() — this is
-     *  what lets ticks update positions without going through Lit's reactive
-     *  simNodes/simLinks properties (see rebuildSimulation()'s doc comment). */
-    private nodeEls;
-    private nodeLabelEls;
-    private expandIndicatorEls;
-    /** Tracks the index/time of the last Enter/Space activation, for double-Enter expand detection
-     *  (mirroring native dblclick semantics for keyboard users). */
-    private lastKeyActivateIndex;
-    private lastKeyActivateTime;
-    /** The last `focusId` value `focusNode()` was auto-invoked for by `updated()`'s declarative
-     *  centering branch -- guards against re-centering on every update while `focusId` stays set
-     *  (see the `focusId` property doc for why it only ever centers once per value). Reset to `null`
-     *  whenever `focusId` itself is cleared, so the same id can center again later. */
-    private lastAppliedFocusId;
-    private focusHaloEl?;
-    private communityHullEls;
-    private communityLabelEls;
-    private canvasEl?;
-    private canvasCtx?;
-    /** Offscreen, same-size, same-camera-transform canvas used only for hit-testing (see
-     *  `redrawPickCanvas()`/`hitTest()`) -- never attached to the DOM or painted to the screen. */
-    private pickCanvas?;
-    private pickCtx?;
-    private canvasResizeObserver?;
-    private canvasDprQuery?;
-    private canvasDrawRafId?;
-    private pickDirty;
-    private canvasCamera;
-    private canvasTooltipEl?;
-    /** Flat, index-aligned list matching `drawPickingScene()`'s own hulls-then-links-then-nodes pick
-     *  order -- rebuilt by `redrawPickCanvas()` alongside the pick canvas itself, so a pick color's
-     *  decoded index always maps back to the exact item it was drawn for. */
-    private pickItems;
-    private canvasDragNode?;
-    private canvasPointerId?;
-    private canvasPointerDownAt?;
-    /** The latest hover pointer position awaiting a hit test -- `pointermove` can fire far more
-     *  often than the display refreshes, and each hit test costs a bounding-rect read plus a
-     *  pick-pixel readback, so hover resolution is coalesced to at most one per animation frame. */
-    private pendingHover?;
-    private hoverRafId?;
-    /** Cached world-space draw scene, reused for camera-only repaints (pan/zoom moves the camera,
-     *  not the scene) -- building it costs a `getComputedStyle()` pass plus full per-node/per-link
-     *  array rebuilds, so it's only invalidated (`markCanvasDirty()`) when data/selection/style
-     *  state or node positions actually change. */
-    private canvasScene?;
-    /** Whether `canvasScene` was built with edge labels included -- the zoom gate makes the scene
-     *  camera-dependent at exactly two thresholds (`edgeLabelMinZoom`, `CANVAS_NODE_LABEL_MIN_ZOOM`),
-     *  so a camera-only draw that crosses either must rebuild instead of reusing the cache. */
-    private canvasSceneHasEdgeLabels;
-    /** The in-flight `requestAnimationFrame` id for a camera tween (`focusNode()`/`fit()`), if any --
-     *  canceled by a new tween request or a user pan/zoom gesture (see `applyInteractions()`'s zoom
-     *  `'start'` handler). */
-    private cameraTweenId?;
-    /** The current tween's own `resolve`, so cancellation (a superseding tween, or a real user
-     *  pan/zoom gesture) settles it with `false` instead of leaving the caller's `Promise` hanging
-     *  forever -- `cancelAnimationFrame()` alone stops the rAF loop but never touches the Promise. */
-    private cameraTweenResolve?;
-    /** True for a camera tween's whole duration (set before its first frame, cleared on
-     *  resolution) -- `isPanning` alone doesn't cover this: `applyZoomTransform()`'s per-frame
-     *  `zoomBehavior.transform()` call on a non-transition selection fires d3-zoom's
-     *  start/zoom/end synchronously within that single call, so `isPanning` flips true-then-false
-     *  within one frame rather than staying true for the tween's real duration the way an actual
-     *  user gesture does. */
-    private isCameraTweening;
-    private linkEls;
-    private linkLabelEls;
-    /** Per-simLink-index flip cache for the length declutter gate -- `onTick()` only writes
-     *  `visibility` when the boolean actually changes, not every tick. */
-    private linkLabelHiddenByLength;
-    private edgeLabelWidthCache;
-    /** Dangling-stub `<line>`s, index-aligned with `danglingLinks` -- cached separately from
-     *  `linkEls` (real, simulated links only) so onTick() can write their positions too; see
-     *  onTick()'s own comment for why a stub needs this at all. */
-    private danglingLinkEls;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    /**
-     * A caller-supplied `radius` is clamped to [MIN_RADIUS, MAX_RADIUS] (and a
-     * non-finite/NaN value falls back to the same default average as an unset
-     * one) — an unclamped 0/negative radius would render an invisibly small
-     * `<circle>` that's still `role="button" tabindex="0"`, an invisible,
-     * focusable/clickable control with no visible focus indicator.
-     */
-    private nodeRadius;
-    /** `width`/`height` normalized to a finite, positive viewport size — an invalid attribute value
-     *  would otherwise flow straight into `forceCenter`, the SVG `viewBox`, and the canvas backing
-     *  store's `width`/`height`, producing `NaN` geometry/transforms that silently render nothing
-     *  instead of erroring. */
-    private get safeWidth();
-    private get safeHeight();
-    /** `minZoom`/`maxZoom` normalized to finite, positive scale bounds before ever reaching
-     *  d3-zoom's `scaleExtent()` or a camera-clamp `Math.min`/`Math.max` — a non-finite bound would
-     *  otherwise poison every subsequent zoom/pan computation with `NaN`. */
-    private get safeMinZoom();
-    private get safeMaxZoom();
-    /** `edgeLabelMinZoom` is compared directly against the live camera scale (same domain as
-     *  `minZoom`/`maxZoom`), so it's normalized with the same bounds -- a non-finite value would
-     *  otherwise make every `>=`/`<` comparison against it silently `false`/`true` forever. */
-    private get safeEdgeLabelMinZoom();
-    /** `seed`, normalized to a finite integer when set -- `undefined` (unseeded/random) is left
-     *  untouched, since it's a meaningful third state, not a missing number. Without this,
-     *  `hashNodeSeed`/`mulberry32`'s `>>> 0` coercion would silently fold `NaN`/`Infinity` to `0`
-     *  instead of normalizing an out-of-range attribute value the way every other numeric prop here
-     *  does. */
-    private get safeSeed();
-    /** `chargeStrength` is a signed d3-force strength (negative = repulsion, positive = attraction)
-     *  — only guarded for finiteness, not clamped to a range, since either sign is a legitimate
-     *  value. */
-    private get safeChargeStrength();
-    /** `linkDistance` normalized to a finite, non-negative pixel distance — feeds `forceLink()`'s
-     *  `distance()`, the layered layout's `gapY`, and the neighbor-jitter spawn radius, none of
-     *  which have a sane meaning for a negative/non-finite value. */
-    private get safeLinkDistance();
-    private resolveNodeType;
-    private nodeShape;
-    /** Resolution precedence: `node.color` (existing, most specific) > matched `GraphNodeType.color`
-     *  > the ordered categorical fallback palette by the type's index in `nodeTypes` > (returns
-     *  `undefined`, letting the untyped `--lr-node-fill` token default apply). Both data-driven
-     *  color sources pass the existing `sanitizeNodeColor()`. */
-    private nodeFill;
-    /** `this.nodes` filtered down to the ids `hiddenTypes` doesn't hide -- an untyped node (`type ==
-     *  null`) is never hidden, regardless of `hiddenTypes`' contents. */
-    private visibleNodes;
-    /** Resolves `this.links` against an already-built `byId` node map: a link whose source isn't in
-     *  `byId` is dropped (hidden source, or a genuinely missing one); a link whose target isn't in
-     *  `byId` either stubs as a dangling link (target id doesn't exist in `this.nodes` at all) or is
-     *  dropped (target exists but is hidden by `hiddenTypes`). Shared by both the force and layered
-     *  layout paths in `rebuildSimulation()`. */
-    private resolveLinksAgainst;
-    /** A community's currently-visible members -- the union of `memberIds` and every currently
-     *  simulated node (already filtered by `hiddenTypes`) whose `communityId` matches. */
-    private communityMembers;
-    /** Memoized `visibleCommunities()` result -- `undefined` means "stale, recompute on next call".
-     *  Cleared from `willUpdate()` whenever `simNodes`/`communities` actually change, the same
-     *  structural-change gate `applyInteractions()` re-caches its own DOM lookups on, so every other
-     *  call site (roving-ring math, `render()`'s template, keyboard navigation) shares one
-     *  `O(communities × simNodes)` computation per structural update instead of repeating it. */
-    private visibleCommunitiesCache?;
-    /** `communities` narrowed to entries with at least one currently-visible member -- a community
-     *  whose members are all hidden by `hiddenTypes` (or that starts out empty) draws no hull and
-     *  doesn't occupy a roving-ring slot. */
-    private visibleCommunities;
-    private communityHull;
-    private onCommunityClick;
-    private cameraTransitionMs;
-    private cancelCameraTween;
-    /** Writing a transform on a plain (non-transition) selection makes d3-zoom fire its own
-     *  start/zoom/end sequence synchronously, in this same call -- `isApplyingZoomTransform` lets
-     *  the zoom `'start'` handler tell that self-triggered echo apart from a genuine external
-     *  gesture, so a camera tween's own per-frame write doesn't cancel itself. */
-    private isApplyingZoomTransform;
-    private applyZoomTransform;
-    /** Animates from the zoom behavior's current transform toward `computeTarget()`'s result via a
-     *  rAF tween that calls `zoomBehavior.transform()` every frame -- keeps d3-zoom's own internal
-     *  state consistent (so the next user pan doesn't jump), unlike writing the `<g>` transform
-     *  attribute directly. `computeTarget` is re-invoked on every single frame (not read once
-     *  up-front) so the tween keeps tracking a still-settling force simulation's live node positions
-     *  instead of tweening toward a stale snapshot from the moment the call was made --
-     *  `focusNode()`/`fit()` are just as likely to run while the graph is still animating its initial
-     *  layout as after it's settled. `prefers-reduced-motion` jumps straight to one write of the
-     *  then-current target. A concurrent call cancels the previous tween -- resolves `true` on
-     *  genuine arrival, `false` if superseded or interrupted by a user gesture before completing. */
-    private tweenCamera;
-    /** Animates the camera so `id` centers in the viewport (the `width` x `height` viewBox), at
-     *  `options.zoom` (clamped to `[minZoom, maxZoom]`) or the current scale when omitted. Resolves
-     *  `true` on arrival; `false` for an id with no matching entry in `simNodes` -- there's nothing
-     *  to center on. Announces `graphNodeFocused` through the existing live region. Does not move DOM
-     *  focus -- this is a camera operation, not a roving-focus one. */
-    focusNode(id: string, options?: {
-        zoom?: number;
-    }): Promise<boolean>;
-    /** Animates the camera to frame the bounding box of every currently visible node position (plus
-     *  each node's own radius) at the largest scale that fits within `width` x `height` minus
-     *  `padding` viewport-px on each side (clamped to `[minZoom, maxZoom]`). Silent -- no data
-     *  changed, so no announcement. A no-op with no visible nodes. */
-    fit(options?: {
-        padding?: number;
-    }): void;
-    private updateFocusHalo;
-    private setUpCanvasSurface;
-    private watchCanvasResize;
-    private watchCanvasDpr;
-    private onCanvasDprChange;
-    private markCanvasDirty;
-    /** The camera-only sibling of `markCanvasDirty()`: a pan/zoom moves the camera but leaves every
-     *  world-space scene value (positions, colors, labels) untouched, so the cached `canvasScene`
-     *  stays valid and only needs redrawing under the new transform. The pick canvas bakes the
-     *  camera transform into its pixels, though, so it still needs a redraw before the next hit
-     *  test. */
-    private markCanvasCameraDirty;
-    private scheduleCanvasDraw;
-    /** Canvas 2D's `fillStyle`/`strokeStyle` don't accept a raw `var(--x)` string the way an inline
-     *  SVG `style` attribute does -- resolves it to the actual cascaded color via `getComputedStyle`
-     *  first (the same "canvas can't consume var() directly" resolution `<lr-heatmap>` already
-     *  uses for its own canvas-drawn tokens). `value` untouched when it isn't a bare `var(...)` ref
-     *  (a literal `GraphNode.color`/`GraphLink.color` hex/rgb string already resolves fine as-is). */
-    private resolveCssColorValue;
-    private buildCanvasScene;
-    /** Sizes the backing store to the canvas's own rendered CSS box (`clientWidth`/`clientHeight`,
-     *  themselves stretched to fill the host via `[part="base"]`/`[part="canvas"]`'s `100%` sizing)
-     *  times `devicePixelRatio`, only touching `width`/`height` when the target actually changed --
-     *  reassigning either unconditionally would implicitly clear the canvas and reset its transform
-     *  on every single draw, even a pure pan/zoom repaint. Mirrors `<lr-heatmap>`'s own DPR-scaled
-     *  backing-store convention (`watchDpr()`/`onDprChange()`), adapted to `setTransform()` (an
-     *  absolute reset) rather than a relative `scale()`, since this canvas -- unlike heatmap's, which
-     *  always resizes its backing store on every draw -- only resizes conditionally. */
-    private drawCanvas;
-    private rebuildPickItems;
-    private redrawPickCanvas;
-    private hitTest;
-    private bindCanvasZoom;
-    private bindCanvasPointer;
-    private onCanvasPointerDown;
-    private onCanvasPointerMove;
-    /** `alpha` decays toward `alphaMin` and d3-force stops its internal timer once it crosses below
-     *  it, so `alpha > alphaMin` mirrors the simulation's own running condition -- including a drag's
-     *  `alphaTarget(0.3)` reheat, and correctly excluding a seeded/reduced-motion graph whose settle
-     *  loop already converged synchronously. */
-    private simulationIsTicking;
-    private onCanvasPointerUp;
-    private onCanvasPointerLeave;
-    private onCanvasDblClick;
-    /** Geometric fallback for dblclick: browsers can deliver the event before the offscreen pick
-     * canvas has painted the latest frame, while the simulation coordinates are already current. */
-    private nodeAtCanvasPoint;
-    private updateCanvasTooltip;
-    private isSelected;
-    private isDimmed;
-    private linkKey;
-    /** Computes and emits the selection intent for activating `id`; never assigns
-     *  `selectedNodeIds`/`selectedLinkIds` itself -- see the class doc's controlled-selection note. */
-    private emitSelectionIntent;
-    private clearSelection;
-    protected willUpdate(changed: PropertyValues): void;
-    protected updated(changed: PropertyValues): void;
-    /** Suppresses hover events/`data-hovered` while a node drag is in progress (tracked from the
-     *  existing d3-drag `.on('start')`/`.on('end')` handlers in `applyInteractions()`) — a drag
-     *  crossing over other nodes/links would otherwise spam enter/leave pairs unrelated to genuine
-     *  pointer hovering. */
-    private isDragging;
-    /** Same purpose as `isDragging`, for d3-zoom pan/zoom gestures (tracked from `applyInteractions()`'s
-     *  zoom `.on('start')`/`.on('end')` handlers, added by this same change). */
-    private isPanning;
-    /**
-     * Imperatively wires up d3-zoom (pan/zoom on the `<svg>`) and d3-drag
-     * (per-node drag) against the just-rendered DOM. The zoom bind itself is a
-     * one-time guard (`zoomedEl`) — but the bound `zoomBehavior`'s
-     * `scaleExtent` is re-read from `minZoom`/`maxZoom` on every call so a
-     * post-mount change to either still takes effect. The node-drag bind +
-     * node/link/label element caching for `onTick()` only run when
-     * `changed` indicates a fresh structural render just happened, not on
-     * every call — otherwise this would re-scan the DOM via
-     * `querySelectorAll` on every Lit update, which used to include every
-     * single simulation tick. `<circle>`s already bound are skipped
-     * (`boundNodeEls`) — a WeakSet reset on every `rebuildSimulation()` so DOM
-     * nodes Lit reuses across a rebuild get rebound against their new datum
-     * instead of a stale one. The zoom handler writes the resulting transform
-     * straight to the cached `gEl` (bound once alongside `zoomedEl`, since the
-     * outer `<g>` is a static part of the template and never recreated by Lit)
-     * instead of assigning a Lit reactive property — panning/zooming fires
-     * continuously while dragging, and reassigning a `@state()` there would
-     * force a full re-render (recomputing every node/link template) on every
-     * single event, the same class of cost `onTick()` already avoids for ticks.
-     */
-    private applyInteractions;
-    /** The `renderer="canvas"` twin of `applyInteractions()`'s svg zoom-bind branch -- binds d3-zoom
-     *  and the pointer/hit-testing handlers to the just-rendered `<canvas>` once (guarded by the same
-     *  `zoomedEl` field `applyInteractions()` uses, so `focusNode()`/`fit()`/`tweenCamera()` keep
-     *  working unmodified against whichever element -- svg or canvas -- is currently bound), then
-     *  marks the canvas dirty on every call so any structural/style-affecting change (new nodes/
-     *  links, a selection change, a hiddenTypes toggle, ...) schedules a fresh draw the same way a
-     *  Lit re-render already does for svg mode. */
-    private applyCanvasInteractions;
-    /**
-     * Runs on every d3-force simulation tick (up to ~300 while a graph settles
-     * on load, continuously while a node is being dragged via
-     * `alphaTarget(0.3)`). Writes positions straight to the already-rendered
-     * DOM via `setAttribute()` instead of reassigning the reactive
-     * `simNodes`/`simLinks` properties, which would force a full Lit re-render
-     * (and, before the structural-render gate in `applyInteractions()`, an
-     * unconditional `querySelectorAll` scan) on every single frame. Writing attributes
-     * directly (rather than wrapping each element in a d3 selection just to
-     * call `.attr()`) avoids allocating a throwaway Selection per element on
-     * this component's highest-frequency code path.
-     */
-    private onTick;
-    private rebuildSimulation;
-    /** Announces the current hidden-node count via the live region -- shared by both the force and
-     *  layered rebuild paths (each calls this with its own final visible-node count) so `hiddenTypes`
-     *  filtering announces identically regardless of `layout`. Called from right here (not from
-     *  willUpdate()/updated() gated on a 'hiddenTypes'/'nodes' PropertyValues diff) because
-     *  rebuildSimulation() itself is also invoked directly from connectedCallback() once the lazy d3
-     *  peer deps resolve -- a call that never goes through Lit's changed-property diffing at all.
-     *  Computing it there instead would miss that path entirely: a graph mounted with hiddenTypes
-     *  already set would compute this from a still-empty simNodes (0 settled nodes yet) on the
-     *  property-driven pass, then never get a chance to correct it once the real simNodes became
-     *  available. Only ever touches graphLiveText when there's something to say -- a node is
-     *  currently hidden, or one just stopped being hidden -- so a consumer that never sets
-     *  hiddenTypes keeps today's exact live-region output. */
-    private announceHiddenNodeCount;
-    /** The `layout="layered"` path: computes final positions synchronously via the shared
-     *  `layeredLayout()` util (2r x 2r boxes, `gapY = linkDistance`, `gapX = 12`), centers the
-     *  drawing in `width` x `height`, and skips forceSimulation() entirely -- no `this.simulation`,
-     *  no ticking, no `prevById` carry-over (deterministic input -> output makes it unnecessary; a
-     *  structural change simply recomputes wholesale). `lr-graph` never passes `fixedPositions`. */
-    private rebuildLayeredLayout;
-    private onNodeClick;
-    /** Returns a node's current position in the graph's local drawing space. */
-    getNodePosition(id: string): {
-        x: number;
-        y: number;
-    } | undefined;
-    private onLinkClick;
-    private onNodeEnter;
-    private onNodeLeave;
-    private onNodeDblClick;
-    private onLinkEnter;
-    private onLinkLeave;
-    private nodeAccessibleText;
-    private linkAccessibleText;
-    private linkCoordinates;
-    /** World-space midpoint of a link, offset EDGE_LABEL_OFFSET_PX perpendicular to the segment
-     *  (horizontal, unrotated text — rotated edge-label text is a readability and RTL hazard). */
-    private edgeLabelPosition;
-    private edgeLabelFontPx;
-    private edgeLabelWidth;
-    /** Toggles `data-edge-labels-hidden` on the cached zoomed `<g>` when crossing `edgeLabelMinZoom`
-     *  -- called from the d3-zoom `'zoom'` handler (render-free, CSS hides `[part="link-label"]`
-     *  beneath the attribute) so this scales with every pan/zoom event without a Lit re-render. */
-    private updateEdgeLabelZoomGate;
-    private graphItemCount;
-    private normalizedGraphItem;
-    private graphItemText;
-    private graphItemAnnouncement;
-    private onGraphItemFocus;
-    private focusGraphItem;
-    /**
-     * The forward physical arrow key (`ArrowRight` in LTR, `ArrowLeft` under
-     * `dir="rtl"` — see `isRtl()`) moves to the next roving-tabindex item, the
-     * backward one to the previous, in flat array order (`simNodes` then
-     * `simLinks`) — the same `forwardKey`/`backwardKey` swap this library's
-     * other "physical arrow key drives sequential previous/next" components
-     * (`<lr-tabs>`, `<lr-slider>`, `<lr-segmented>`) apply under RTL.
-     * `ArrowDown`/`ArrowUp` always mean next/previous regardless of direction.
-     */
-    private onGraphKeyDown;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lr-graph': LyraGraph;
-    }
-}
-//# sourceMappingURL=graph.class.d.ts.map