🥮 mooncakes.io
    Sign in

    mizchi/crater-core/node does not have a README file

    DispatchFn

    source

    Dispatch function type - passed through layout computation to enable cross-layout-type dispatch without global state. The function takes (node, context, dispatch) and returns Layout.

    LayoutDispatchFunc

    source

    @deprecated Use DispatchFn instead Layout dispatch function type (kept for backward compatibility with incremental compute)

    Node

    source
    pub struct Node {
      id : String
      uid : Int
      style : 
    Style
      children : Array[Node]
      measure : 
    MeasureFunc    ?
      text : String?
      src : String?
      dom_id : Int?
    }

    A node in the layout tree

    Node::leaf

    source
    fn Node::leaf(id : String, style : 
    Style    ) -> Node

    Node::new

    source
    fn Node::new(id : String, style : 
    Style    , children : Array[Node]) -> Node

    Node::set_dom_id

    source
    fn Node::set_dom_id(self : Node, dom_id : Int?) -> Unit

    Attach the originating DomTree node id (dynamic-rendering path).

    Node::set_uid

    source
    fn Node::set_uid(self : Node, uid : Int) -> Unit

    Overwrite the cache uid. Used to stabilize uids across re-renders so incremental reflow can match a rebuilt node to its prior layout (see stabilize_uids).

    Node::text

    source
    fn Node::text(id : String, style : 
    Style    , measure : 
    MeasureFunc    , content : String) -> Node

    Create a text node with content

    Node::with_measure

    source
    fn Node::with_measure(id : String, style : 
    Style    , measure : 
    MeasureFunc    , text? : String, src? : String?) -> Node

    Create a leaf node with a custom measure function Optional text parameter for alt text (images) or other content

    Node::with_uid

    source
    fn Node::with_uid(id : String, uid : Int, style : 
    Style    , children : Array[Node]) -> Node

    Create a node with a specific uid (for incremental layout)

    Node::with_uid_and_measure

    source
    fn Node::with_uid_and_measure(id : String, uid : Int, style : 
    Style    , children : Array[Node], measure : 
    MeasureFunc    ?, text : String?, src? : String?) -> Node

    Create a node with a specific uid and measure function

    UidRegistry

    source
    pub struct UidRegistry {
      dom_to_uid : Map[Int, Int]
      anon_to_uid : Map[String, Int]
      next : Int
    }

    Stable uid assignment for incremental reflow.

    LayoutTree keys its per-node layout cache by Node.uid, but the dynamic- rendering path rebuilds the render node tree from scratch on every DOM mutation, so a plain next_uid() would hand every node a fresh uid and the cache would never match (see docs/incremental-reflow-design.md). A UidRegistry persists across rebuilds and maps a node's stable identity to a stable uid:

    • elements carry their originating DomTree node id (Node.dom_id, phase A), so they key on that and survive moves / re-renders;
    • anonymous / text boxes (no dom_id) key on their owning node's stable uid plus their child index, which is stable as long as the surrounding structure is.

    uids are allocated from the registry's own monotonic counter, so they are unique within the registry (and therefore within any one LayoutTree built from a stabilized tree).

    UidRegistry::new

    source

    clear_node_clean_predicate

    source
    fn clear_node_clean_predicate() -> Unit

    Remove the subtree-clean predicate (back to the conservative default where every node reports not-clean, disabling block-flow memoization).

    fallback_layout

    source

    Create a minimal fallback layout for a node (used when dispatch is unavailable)

    get_layout_dispatcher

    source
    fn get_layout_dispatcher() -> LayoutDispatchFunc?

    Get the global layout dispatcher

    node_incremental_active

    source
    fn node_incremental_active() -> Bool

    Whether an incremental layout is in progress (the clean predicate is installed). Block-flow memoization populates its cache only while this is true, so the static / full-layout path neither reads nor writes it.

    node_is_clean

    source
    fn node_is_clean(uid : Int) -> Bool

    Whether the node with this uid has an entirely unchanged subtree since the last layout, per the installed predicate. false when no predicate is installed (the safe default: recompute).

    set_layout_dispatcher

    source
    fn set_layout_dispatcher(f : LayoutDispatchFunc) -> Unit

    Set the global layout dispatcher (used by incremental compute for caching)

    set_node_clean_predicate

    source
    fn set_node_clean_predicate(f : (Int) -> Bool) -> Unit

    Install the subtree-clean predicate for the duration of an incremental layout. Pass None (via clear_node_clean_predicate) to remove it afterwards.

    stabilize_uids

    source
    fn stabilize_uids(root : Node, registry : UidRegistry) -> Unit

    Rewrite every uid in root to its stable value from registry, in place. Call this on a freshly built render node tree before handing it to LayoutTree::from_node / reconcile_from: nodes that map to the same DomTree element (or the same anonymous slot) keep their uid across rebuilds, so the incremental layout cache matches.

    str_has_prefix

    source
    fn str_has_prefix(s : String, prefix : String) -> Bool

    Allocation-free prefix test. String::has_prefix in core uses Boyer-Moore- Horspool and allocates a skip table per call; layout calls it per node (text detection via id.has_prefix("#text")), which made it the single largest allocation site in the render pipeline. This compares the prefix directly.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io