@searsuite/sear-render-node

Creates a scene graph bound to one editor-local DI runtime.

DI token for resolving the scene graph.

Replaces all scene nodes owned by one plugin.

SceneGraph is cleared through strategy-owned dirty regions.

SceneGraph is a root container and is not drawn into the hit layer directly.

SceneGraph is a root container and is not drawn directly.

Marks and removes all existing top-level nodes owned by one plugin.

Reconciles one plugin's top-level nodes by stable node key.

Existing nodes with keys that are still present can be retained, new keys are inserted, and keys no longer returned by the plugin are removed. This is the block-level retained path used by virtualized document rendering.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Keys of direct child nodes registered via add(), used for recursive cleanup.

Render and event ordering depth for Node.

Name of the node, defaults to the class name.

Stable key used by SceneGraph, DataStorage and spatial indexes.

Parent node's stable render key, used for tree relationships.

Rectangle representing the node's position and size.

Visual and geometric properties of the node.

Unique random color key used for hit detection.

Whether this node remains fixed while its scroll container moves.

Adds an event listener for the specified event type.

Binds this node tree to the editor-local services owned by one SceneGraph.

Clears state owned by Node.

Disposes this node and all of its descendants recursively. Removes nodes from DataStorage and positionRectStorage, and releases their hit color keys.

Draws the node in both the scene and hit detection contexts.

Abstract method to draw the node's hit detection representation. Must be implemented by subclasses.

Abstract method to draw the node's scene representation. Must be implemented by subclasses.

Finds a node by its stable render-node key.

ReturnsThe node if found, otherwise null.

Finds a node by its random color key.

ReturnsThe node if found, otherwise null.

Queries all nodes within a given rectangular range.

ReturnsAn array of nodes found within the range.

Removes a child node from this node and disposes its entire subtree.

Removes an event listener for the specified event type.

Marks this node tree as sticky and applies the supplied affix axes to every descendant.

Converts the node and its properties to a JSON object. Can be extended to recursively serialize children.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Creates a block manager from the text-shaping and rich-text services.

Maximum measured unwrapped block width.

DI token for resolving the rich-document block manager.

Adds a rich document block and records its measured size.

Calculates a flattened list of wrapped rich-text lines for all blocks.

Calculates wrapped rich-text lines per paragraph while preserving paragraph mapping.

Clears all measured blocks and cached size information.

Creates an unshared measurement workspace for a read-only layout request.

Closes direct block writes after the owning editor has assembled.

Selects the transient base font used for the next layout pass.

Unique random color key for hit detection.

Iterates every descendant in scene order.

Returns descendants whose boundaries intersect the supplied rectangle.

Removes the value.

Serializes this scene structure into diagnostic JSON.

Updates the indexed boundary after geometry changes.

DI token used to resolve the dirty tree implementation.

DI token for resolving GenerationalDirtyTracker.

Frame-end full cleanup (called by DirtyRenderStrategy.render()). All items are removed regardless of generation.

Returns the boundary.

Records a region until the current dirty render pass finishes.

Returns dirty nodes for the requested render generation.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

The maximum number of entries retained by this spatial node.

The parent spatial node, or null at the root.

DI token for resolving Tree.

Clears state owned by Tree.

Returns the boundary.

Inserts a bounded entry into the spatial index.

Returns indexed entries whose boundaries intersect the supplied rectangle.

Removes the value.

Serializes this scene structure into diagnostic JSON.

Updates the indexed boundary after geometry changes.

Space reserved before projected text for a cell visual.

Raw General-format number fitted against the actual render width.

Suppresses projected text while preserving its underlying value.

Stable render-node key.

When omitted, Node falls back to its generated hit color key for backwards compatibility. Semantic render nodes should provide stable ids such as block ids here instead of using hit colors as identity.

Optional world-coordinate clip applied by OverlayRenderStrategy. Overlay nodes normally render above sticky UI; this lets a visual stay within a host-defined content region instead (for example, a sheet selection must not draw over row/column headers).

Stable semantic ownership exposed by retained render targets.

Stable semantic role exposed by retained render targets.

Business marker: true when selection represents a whole row or whole column range. Dirty render may use this to choose a different redraw shape.

Visual-only nodes do not participate in hit canvas.

Background: FixBoxNode.drawHit fills the entire rect with random color for Hit Canvas lookup. But once visual-only nodes (such as selection strokes and header highlight backgrounds) enter the Hit Canvas, they can cover underlying cell hit colors and block click-through. Setting skipHit: true in properties makes drawHit skip directly.

Foreground color used by text-rendering nodes.

Character repeated to fill the remaining inline width of formatted text.

Maximum width available to single-line text across adjacent empty cells.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Affix nodes render in the sticky strategy instead of the scrolled content layer.

Constructs a text node and measures its width against the active render context.

Affix text renders in the sticky strategy together with its parent.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Clears state owned by BoxNode.

Draws the hit area for this node and all its descendants. This is typically used for hit testing (e.g., detecting mouse clicks).

Draws the scene for this node and all its descendants. This method recursively calls drawScene on all child nodes.

Constructs a dashed line node.

Clears the line bounds with stroke padding.

Dashed lines are visual-only and do not participate in hit testing.

Draws the dashed line into the render context.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Clears this node's bounds from a raster context using stroke padding.

Draws the node into the hit-test context unless the node is visual-only.

Draws the box into the visible render context.

Constructs a new Node<T> instance with specified properties and position. Updates the boundary in the positionRectStorage if necessary.

Constructs a text node and measures its width against the active render context.

Text draws above the box background by default.

Text value rendered by this node.

Text nodes are cleared through their parent box dirty region.

Text nodes do not draw separate hit regions; the parent box owns hit testing.

Draws text inside the parent node using the parent's alignment and padding.

Creates a viewport overlay render node.

Draws overlay content; the node owns transform isolation for viewport-space plugins.

Clears state owned by Node.

Abstract method to draw the node's hit detection representation. Must be implemented by subclasses.

Abstract method to draw the node's scene representation. Must be implemented by subclasses.

Ordered labels, clipped to the layer bounds without changing the cell value.

Creates a caret overlay node.

Draws the caret when the blink state says it is visible.

Creates an IME composition overlay node.

Draws composing text in world or viewport coordinates.

Creates a rich-text content node from pre-computed layout lines.

Draws every included layout line inside this node's clip.

Creates a line renderer with domain style comparison and run rendering.

DI token for resolving the line renderer.

Paints one laid-out line at the supplied world-space origin.

Creates a run renderer backed by the render contribution registry.

DI token for resolving the run renderer.

Paints one run and restores all renderer state changed by its style plugins.

DI token for resolving the rich-text run render registry.

Applies all registered render-state contributions before text painting.

Paints all registered plugin-owned run details.

Registers one render contribution.

Resolves the final font descriptor after all registered contributions run.

Creates a selection overlay node.

Draws selection rectangles in world or viewport coordinates.

World-space regions where text should be painted above the highlight.

Rich-text visual node pixels are cleared by strategy-owned dirty rectangles.

Rich-text visual nodes are ignored by hit testing unless a subclass opts in.

Stable contribution key used for duplicate detection and unregister.

Applies renderer state before the text run is painted.

Paints plugin-owned details for an already painted text run.

Resolves the font used by shaping and painting for a styled run.

Creates a block-level rich-text scene node.

Draws all visible text runs inside this block.

Stable top-level rich-text block id.

Top-level rich-text block index.

Layout line index inside the full rich-text snapshot.

Semantic role for rich-text render nodes.

Creates a text-run scene node.

Draws the text run into the active world-space transform.

Constructs a BVH with a broad default world boundary.

Removes all indexed items.

Returns the current tree boundary.

Inserts one item into the root child list.

Returns items whose rectangles intersect the query range.

Removes one item by object identity.

Serializes debug data for this spatial index.

Replaces the tree boundary and clears indexed items.

Triggers an event, calling all associated handlers in registration order.

Propagation control: If any handler synchronously returns false, dispatch to subsequent handlers stops. Returning true / undefined / void means dispatch continues.

This enables ordered plugin suppression for the same event (for example, a cell editor can block a selection plugin on dblClick) without direct plugin-to-plugin state mutation.

Returnsfalse if a handler actively stopped propagation; otherwise true.

Closes registration changes after an owning runtime has assembled.

Removes event handlers for a specific event or all events.

Registers an event handler for a specific event.

ReturnsThe current instance to allow method chaining.

Constructs a Hilbert R-tree.

Removes all indexed items.

Returns the current tree boundary.

Inserts one item and maintains Hilbert ordering.

Returns items whose rectangles intersect the query range.

Removes an item by matching rectangle bounds.

Serializes debug data for this spatial index.

Replaces the boundary and clears indexed items.

DI token for resolving the hit-color registry.

Clears all registered hit-color mappings.

Removes a hit-canvas color key mapping.

Resolves the node currently associated with a hit-canvas color key.

Registers a node for hit-canvas color lookup.

Constructs a KD-tree.

Removes all indexed items.

Returns the current tree boundary.

Inserts an item by alternating x/y split axes.

Returns items whose rectangles intersect the query range.

Removes one item by object identity and rebuilds the experimental tree.

Serializes debug data for this spatial index.

Replaces the boundary and clears indexed items.

Constructs an Octree with a broad default world boundary.

Removes all indexed items.

Returns the current tree boundary.

Inserts one item into the root child list.

Returns items whose rectangles intersect the query range.

Removes one item by object identity.

Serializes debug data for this spatial index.

Replaces the boundary and clears indexed items.

Constructs a QuadTree node.

Bottom-left child node.

Bottom-right child node.

Whether this node has been subdivided into children.

Rectangles stored directly in this node.

Top-left child node.

Top-right child node.

Clears all indexed rectangles and child quadrants.

Returns whether boundary fully contains rect.

Returns the root boundary for this tree node.

Inserts a rectangle into the tree.

ReturnsTrue when data intersects this tree boundary.

Returns whether two rectangles overlap.

Queries rectangles intersecting a range.

ReturnsMatching rectangles.

Removes matching rectangle entries.

ReturnsTrue when an entry was removed.

Splits this node into four child quadrants and redistributes contained items.

Serializes debug data for this tree.

Replaces the boundary and reinserts existing rectangles.

Creates a QuadTree.

Constructs an R-tree with a broad default world boundary.

Removes all indexed items.

Returns the current tree boundary.

Inserts one item into the root child list.

Returns items whose rectangles intersect the query range.

Removes one item by object identity.

Serializes debug data for this spatial index.

Replaces the boundary and clears indexed items.

Constructs a spatial hash index.

Removes all indexed items.

Returns the current tree boundary.

Inserts an item into the bucket containing its top-left corner.

Returns items in intersecting buckets whose rectangles overlap the query range.

Removes one item from its hashed bucket.

Serializes debug data for this spatial index.

Replaces the boundary and clears indexed items.