🥮 mooncakes.io
    Sign in

    mizchi/crater-dom/dom does not have a README file

    CoreError

    source
    pub enum CoreError {
      NodeNotFound(node_id~ : NodeId)
      InvalidOperation(message~ : String)
    } derive(
    Debug    )

    Core error types
    impl Show for CoreError

    DomNode

    source
    type DomNode

    Internal DOM node representation

    DomTree

    source
    pub struct DomTree {
      next_id : Int
      nodes : Map[Int, DomNode]
      root_id : Int
      focused_node : Int?
      mutations : MutationQueue
    }

    DOM Tree - the core document structure This is the single source of truth for all DOM operations

    DomTree::append_child

    source
    fn DomTree::append_child(self : DomTree, parent : NodeId, child : NodeId) -> Result[Unit, CoreError]

    Append child to parent

    DomTree::assigned_slot

    source
    fn DomTree::assigned_slot(self : DomTree, node : NodeId) -> NodeId?

    Node.assignedSlot. Returns the slot that node is assigned to, or None when node is not a slottable assigned to a slot in its parent host's shadow tree.

    DomTree::attach_existing_shadow_root

    source
    fn DomTree::attach_existing_shadow_root(self : DomTree, host : NodeId, shadow_root : NodeId, mode : String) -> Result[Unit, CoreError]

    Mark an existing document fragment as the host's shadow root

    DomTree::attach_existing_shadow_root_with_init

    source
    fn DomTree::attach_existing_shadow_root_with_init(self : DomTree, host : NodeId, shadow_root : NodeId, init : ShadowRootInit) -> Result[Unit, CoreError]

    DomTree::attach_shadow

    source
    fn DomTree::attach_shadow(self : DomTree, host : NodeId, mode : String) -> Result[NodeId, CoreError]

    Attach a new shadow root to a host element

    DomTree::attach_shadow_with_init

    source
    fn DomTree::attach_shadow_with_init(self : DomTree, host : NodeId, init : ShadowRootInit) -> Result[NodeId, CoreError]

    DomTree::clear_mutations

    source
    fn DomTree::clear_mutations(self : DomTree) -> Unit

    Clear all pending mutations without processing

    DomTree::collect_shadow_matched_declarations

    source
    fn DomTree::collect_shadow_matched_declarations(self : DomTree, host : NodeId, rules : Array[
    CSSRule    ], target : NodeId) -> Array[
    Declaration    ]

    Declarations from rules that apply to target when the rules are authored inside the shadow tree whose host is host, stamped with the matched selector's specificity and document source order so @css.cascade_declarations resolves the winner exactly like the document cascade (@cascade.cascade_rule_into). A rule whose selector fails to parse or does not match is skipped, so one malformed selector cannot abort styling.

    DomTree::create_comment

    source
    fn DomTree::create_comment(self : DomTree, content : String) -> NodeId

    Create a comment node

    DomTree::create_document_fragment

    source
    fn DomTree::create_document_fragment(self : DomTree) -> NodeId

    Create a document fragment node

    DomTree::create_element

    source
    fn DomTree::create_element(self : DomTree, tag_name : String) -> NodeId

    Create an element node

    DomTree::create_runtime_node

    source
    fn DomTree::create_runtime_node(self : DomTree, id : Int, node_type : NodeType, tag_name? : String, text_content? : String) -> Result[NodeId, CoreError]

    DomTree::create_text

    source
    fn DomTree::create_text(self : DomTree, content : String) -> NodeId

    Create a text node

    DomTree::flush_mutations

    source
    fn DomTree::flush_mutations(self : DomTree) -> (Array[MutationRecord], FlushResult)

    Flush pending mutations and return optimized records Returns (records, result) where records is the optimized mutation list and result contains statistics about the flush operation

    DomTree::flush_mutations_with

    source
    fn[T] DomTree::flush_mutations_with(self : DomTree, handler : (MutationRecord) -> T) -> (Array[T], FlushResult)

    Flush mutations with a custom handler for each record Useful for applying mutations to other systems (e.g., LayoutTree)

    DomTree::get_attribute

    source
    fn DomTree::get_attribute(self : DomTree, node : NodeId, name : String) -> Result[String?, CoreError]

    Get attribute from element

    DomTree::get_attributes

    source
    fn DomTree::get_attributes(self : DomTree, node : NodeId) -> Result[Array[(String, String)], CoreError]

    Get all attributes

    DomTree::get_bbox

    source
    fn DomTree::get_bbox(self : DomTree, node_id : NodeId, options? : GetBBoxOptions) -> SVGRect?

    Get the bounding box of an SVG element Returns the tight bounding box in user space coordinates

    DomTree::get_cached_rect

    source
    fn DomTree::get_cached_rect(self : DomTree, node : NodeId) -> Rect?

    Get cached rect

    DomTree::get_children

    source
    fn DomTree::get_children(self : DomTree, node : NodeId) -> Result[Array[NodeId], CoreError]

    Get child nodes

    DomTree::get_composed_children

    source
    fn DomTree::get_composed_children(self : DomTree, node : NodeId, shadow_host? : NodeId?) -> Array[NodeId]

    Return the composed children for a node in the current tree scope.

    • Shadow hosts expose their shadow root children instead of light DOM children.
    • Slot elements inside a shadow tree expose assigned light DOM nodes, falling back to their own children when no assignment exists.

    DomTree::get_ctm

    source
    fn DomTree::get_ctm(self : DomTree, node_id : NodeId) -> SVGMatrix?

    Get the Current Transformation Matrix (CTM) Returns the transformation from user space to viewport

    DomTree::get_custom_states

    source
    fn DomTree::get_custom_states(self : DomTree, node : NodeId) -> Result[Array[String], CoreError]

    DomTree::get_document

    source
    fn DomTree::get_document(self : DomTree) -> NodeId

    Get document root

    DomTree::get_first_child

    source
    fn DomTree::get_first_child(self : DomTree, node : NodeId) -> Result[NodeId?, CoreError]

    Get first child

    DomTree::get_focus

    source
    fn DomTree::get_focus(self : DomTree) -> NodeId?

    Get focused element

    DomTree::get_form_associated_state

    source
    fn DomTree::get_form_associated_state(self : DomTree, node : NodeId) -> Result[(String?, String?), CoreError]

    DomTree::get_host

    source
    fn DomTree::get_host(self : DomTree, node : NodeId) -> Result[NodeId?, CoreError]

    Get host for a shadow root

    DomTree::get_mutation_queue

    source
    fn DomTree::get_mutation_queue(self : DomTree) -> MutationQueue

    Get direct access to the mutation queue (for advanced use cases)

    DomTree::get_next_sibling

    source
    fn DomTree::get_next_sibling(self : DomTree, node : NodeId) -> Result[NodeId?, CoreError]

    Get next sibling

    DomTree::get_node_info

    source
    fn DomTree::get_node_info(self : DomTree, node : NodeId) -> Result[NodeInfo, CoreError]

    Get node info

    DomTree::get_parent

    source
    fn DomTree::get_parent(self : DomTree, node : NodeId) -> Result[NodeId?, CoreError]

    Get parent node

    DomTree::get_root_node

    source
    fn DomTree::get_root_node(self : DomTree, node : NodeId, composed? : Bool) -> Result[NodeId, CoreError]

    Get root node for a node

    DomTree::get_screen_ctm

    source
    fn DomTree::get_screen_ctm(self : DomTree, node_id : NodeId) -> SVGMatrix?

    Get the Screen CTM Returns the transformation from user space to screen pixels

    DomTree::get_shadow_init

    source
    fn DomTree::get_shadow_init(self : DomTree, node : NodeId) -> Result[ShadowRootInit?, CoreError]

    DomTree::get_shadow_mode

    source
    fn DomTree::get_shadow_mode(self : DomTree, node : NodeId) -> Result[String?, CoreError]

    Get shadow mode for a shadow root

    DomTree::get_shadow_root

    source
    fn DomTree::get_shadow_root(self : DomTree, host : NodeId) -> Result[NodeId?, CoreError]

    Get shadow root for a host element

    DomTree::get_tag_name

    source
    fn DomTree::get_tag_name(self : DomTree, node : NodeId) -> Result[String, CoreError]

    Get tag name

    DomTree::get_text_content

    source
    fn DomTree::get_text_content(self : DomTree, node : NodeId) -> Result[String, CoreError]

    Get text content

    DomTree::has_pending_mutations

    source
    fn DomTree::has_pending_mutations(self : DomTree) -> Bool

    Check if there are pending mutations

    DomTree::has_shadow_roots

    source
    fn DomTree::has_shadow_roots(self : DomTree) -> Bool

    DomTree::insert_before

    source
    fn DomTree::insert_before(self : DomTree, parent : NodeId, child : NodeId, reference : NodeId?) -> Result[Unit, CoreError]

    Insert child before reference node

    DomTree::is_slot_element

    source
    fn DomTree::is_slot_element(self : DomTree, node : NodeId) -> Bool

    Whether a node is a slot element

    DomTree::matches_shadow_scoped

    source
    fn DomTree::matches_shadow_scoped(self : DomTree, subject : NodeId, selector : String, host : NodeId) -> Result[Bool, CoreError]

    Match subject against selector as authored inside the shadow tree whose host is host. Returns whether the subject is selected. An unparseable selector yields InvalidOperation.

    DomTree::new

    source
    fn DomTree::new() -> DomTree

    Create a new empty DOM tree

    DomTree::node_to_selector_element

    source
    fn DomTree::node_to_selector_element(self : DomTree, id : NodeId) -> 
    Element    ?

    Project an element node into a standalone @selector.Element (carrying its own tag / id / classes / attributes and element-sibling index/count, with no ancestor chain). None for non-element nodes. This is the same type the renderer's cascade consumes (@css.Element re-exports @selector.Element), so a shadow-tree node can be styled through the renderer pipeline.

    DomTree::pending_mutation_count

    source
    fn DomTree::pending_mutation_count(self : DomTree) -> Int

    Get number of pending mutations

    DomTree::query_selector

    source
    fn DomTree::query_selector(self : DomTree, root : NodeId, selector : String) -> Result[NodeId?, CoreError]

    Query selector — returns the first matching node in document order.

    DomTree::query_selector_all

    source
    fn DomTree::query_selector_all(self : DomTree, root : NodeId, selector : String) -> Result[Array[NodeId], CoreError]

    Query selector all — returns every matching node in document order.

    DomTree::remove_attribute

    source
    fn DomTree::remove_attribute(self : DomTree, node : NodeId, name : String) -> Result[Unit, CoreError]

    Remove attribute from element

    DomTree::remove_child

    source
    fn DomTree::remove_child(self : DomTree, parent : NodeId, child : NodeId) -> Result[Unit, CoreError]

    Remove child from parent

    DomTree::set_attribute

    source
    fn DomTree::set_attribute(self : DomTree, node : NodeId, name : String, value : String) -> Result[Unit, CoreError]

    Set attribute on element

    DomTree::set_cached_rect

    source
    fn DomTree::set_cached_rect(self : DomTree, node : NodeId, rect : Rect) -> Unit

    Set cached rect (called by layout engine)

    DomTree::set_custom_states

    source
    fn DomTree::set_custom_states(self : DomTree, node : NodeId, states : Array[String]) -> Result[Unit, CoreError]

    DomTree::set_focus

    source
    fn DomTree::set_focus(self : DomTree, node : NodeId?) -> Unit

    Set focused element

    DomTree::set_form_associated_state

    source
    fn DomTree::set_form_associated_state(self : DomTree, node : NodeId, form_value : String?, form_state_value : String?) -> Result[Unit, CoreError]

    DomTree::set_mutation_recording

    source
    fn DomTree::set_mutation_recording(self : DomTree, on : Bool) -> Unit

    Enable or disable mutation recording. Off by default: records exist only to feed the incremental-layout bridge, so a standalone tree (querySelector / one-shot build) records nothing. The bridge enables it on the trees it owns.

    DomTree::set_text_content

    source
    fn DomTree::set_text_content(self : DomTree, node : NodeId, content : String) -> Result[Unit, CoreError]

    Set text content

    DomTree::shadow_cascaded_values

    source

    Cascade the shadow rules that apply to target (host is host) into the winning @cascade.CascadedValues, resolving specificity / source order via the shared @css.cascade_declarations.

    DomTree::shadow_query_selector

    source
    fn DomTree::shadow_query_selector(self : DomTree, shadow_root : NodeId, selector : String) -> Result[NodeId?, CoreError]

    Shadow-scoped querySelector: the first shadow-tree element selected by selector in document order, or None.

    DomTree::shadow_query_selector_all

    source
    fn DomTree::shadow_query_selector_all(self : DomTree, shadow_root : NodeId, selector : String) -> Result[Array[NodeId], CoreError]

    Shadow-scoped querySelectorAll: every shadow-tree element selected by selector, in document order. shadow_root must be a shadow root node; its host (resolved from the shadow root) anchors :host / :host-context / ::slotted resolution. An invalid selector yields InvalidOperation.

    DomTree::shadow_stylesheet_rules

    source
    fn DomTree::shadow_stylesheet_rules(self : DomTree, shadow_root : NodeId) -> Array[
    CSSRule    ]

    Parse every <style> element in the shadow tree rooted at shadow_root into a flat list of rules, in document order. Nested elements are descended, but nested shadow roots are not (their styles belong to their own tree).

    DomTree::slot_assigned_elements

    source
    fn DomTree::slot_assigned_elements(self : DomTree, slot : NodeId, flatten? : Bool) -> Array[NodeId]

    HTMLSlotElement.assignedElements(). Like slot_assigned_nodes but filtered to element nodes.

    DomTree::slot_assigned_nodes

    source
    fn DomTree::slot_assigned_nodes(self : DomTree, slot : NodeId, flatten? : Bool) -> Array[NodeId]

    HTMLSlotElement.assignedNodes(). Returns the slottable nodes (elements and text) assigned to slot, in tree order.

    With flatten, an empty assignment falls back to the slot's own children (its default content), and any assigned slot is recursively replaced by its own flattened assigned nodes — matching assignedNodes({ flatten: true }).

    FlushResult

    source
    pub struct FlushResult {
      processed : Int
      nodes_affected : Int
      needs_layout : Bool
    } derive(
    Debug    )

    Result of flushing the mutation queue
    impl Show for FlushResult

    GetBBoxOptions

    source
    pub struct GetBBoxOptions {
      fill : Bool
      stroke : Bool
      markers : Bool
      clipped : Bool
    } derive(Eq, 
    Debug    )

    Options for getBBox() method Corresponds to SVGBoundingBoxOptions in the spec

    GetBBoxOptions::all

    source

    Create getBBox options with all geometry

    GetBBoxOptions::default

    source

    Default getBBox options (fill only)

    MutationQueue

    source
    pub struct MutationQueue {
      records : Array[MutationRecord]
      dirty_nodes : Map[Int, Bool]
      is_flushing : Bool
      deferred : Array[MutationRecord]
      recording : Bool
    }

    Queue for batching mutations

    MutationQueue::clear

    source
    fn MutationQueue::clear(self : MutationQueue) -> Unit

    Clear all pending mutations without processing

    MutationQueue::flush

    source

    Flush the queue and return optimized records for processing The caller is responsible for applying these to the layout tree

    MutationQueue::flush_with

    source
    fn[T] MutationQueue::flush_with(self : MutationQueue, handler : (MutationRecord) -> T) -> (Array[T], FlushResult)

    Process mutations with a callback for each record Returns the flush result

    MutationQueue::has_pending

    source
    fn MutationQueue::has_pending(self : MutationQueue, node : NodeId) -> Bool

    Check if a node has pending mutations

    MutationQueue::is_empty

    source
    fn MutationQueue::is_empty(self : MutationQueue) -> Bool

    Check if queue is empty

    MutationQueue::length

    source
    fn MutationQueue::length(self : MutationQueue) -> Int

    Get number of pending mutations

    MutationQueue::new

    source

    Create a new empty mutation queue

    MutationQueue::optimize

    source

    Optimize the queue by merging related mutations

    MutationQueue::push

    source
    fn MutationQueue::push(self : MutationQueue, record : MutationRecord) -> Unit

    Add a mutation record to the queue

    MutationQueue::record_attribute

    source
    fn MutationQueue::record_attribute(self : MutationQueue, target : NodeId, name : String, old_value? : String?, new_value? : String?) -> Unit

    Build and queue an attribute-change record only when recording.

    MutationQueue::record_character_data

    source
    fn MutationQueue::record_character_data(self : MutationQueue, target : NodeId, old_value? : String?, new_value? : String?) -> Unit

    Build and queue a character-data record only when recording.

    MutationQueue::record_child_added

    source
    fn MutationQueue::record_child_added(self : MutationQueue, target : NodeId, child : NodeId) -> Unit

    Build and queue a child-list "added" record only when recording, so the record and its single-element array allocate nothing on standalone trees.

    MutationQueue::record_child_removed

    source
    fn MutationQueue::record_child_removed(self : MutationQueue, target : NodeId, child : NodeId) -> Unit

    Build and queue a child-list "removed" record only when recording.

    MutationQueue::set_recording

    source
    fn MutationQueue::set_recording(self : MutationQueue, on : Bool) -> Unit

    Enable or disable mutation recording. When disabled (the default), push is a no-op, so building a tree with no mutation consumer allocates no records.

    MutationRecord

    source
    pub struct MutationRecord {
      type_ : MutationType
      target : NodeId
      added_nodes : Array[NodeId]
      removed_nodes : Array[NodeId]
      attribute_name : String?
      old_value : String?
      new_value : String?
      changed_properties : Array[String]
    } derive(
    Debug    )

    Record of a single DOM mutation

    MutationRecord::affects_layout

    source
    fn MutationRecord::affects_layout(self : MutationRecord) -> Bool

    Check if this mutation affects layout (vs paint-only)

    MutationRecord::attribute

    source
    fn MutationRecord::attribute(target : NodeId, name : String, old_value? : String?, new_value? : String?) -> MutationRecord

    Create an Attributes mutation record

    MutationRecord::character_data

    source
    fn MutationRecord::character_data(target : NodeId, old_value? : String?, new_value? : String?) -> MutationRecord

    Create a CharacterData mutation record

    MutationRecord::child_list

    source
    fn MutationRecord::child_list(target : NodeId, added? : Array[NodeId], removed? : Array[NodeId]) -> MutationRecord

    Create a ChildList mutation record

    MutationRecord::style_change

    source
    fn MutationRecord::style_change(target : NodeId, properties : Array[String]) -> MutationRecord

    Create a StyleChange mutation record

    MutationType

    source
    pub enum MutationType {
      ChildList
      Attributes
      CharacterData
      StyleChange
    } derive(Eq, 
    Debug    )

    Type of DOM mutation

    NodeId

    source
    pub struct NodeId(Int) derive(Eq, Hash, 
    Debug    )

    Node identifier - opaque handle to a DOM node
    impl Show for NodeId

    NodeId::from_int

    source
    fn NodeId::from_int(id : Int) -> NodeId

    Create NodeId from Int

    NodeId::to_int

    source
    fn NodeId::to_int(self : NodeId) -> Int

    Get Int value from NodeId

    NodeInfo

    source
    pub struct NodeInfo {
      node_id : NodeId
      node_type : NodeType
      node_name : String
      node_value : String
      child_count : Int
    } derive(
    Debug    )

    Basic node information
    impl Show for NodeInfo

    NodeType

    source
    pub(all) enum NodeType {
      Document
      DocumentType
      Element
      Text
      Comment
      DocumentFragment
      ShadowRoot
    } derive(Eq, 
    Debug    )

    Node type enumeration
    impl Show for NodeType

    NodeType::from_dom_constant

    source
    fn NodeType::from_dom_constant(value : Int) -> NodeType?

    Convert DOM node type constant to NodeType See: https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType

    Point

    source
    pub struct Point {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    2D Point
    impl Show for Point

    Rect

    source
    pub struct Rect {
      x : Double
      y : Double
      width : Double
      height : Double
    } derive(Eq, 
    Debug    )

    Rectangle with position and size
    impl Show for Rect

    Rect::center

    source
    fn Rect::center(self : Rect) -> Point

    Convert Rect to center point

    Rect::new

    source
    fn Rect::new(x : Double, y : Double, width : Double, height : Double) -> Rect

    Create a new Rect

    SVGAngle

    source
    pub struct SVGAngle {
      unit_type : SVGAngleType
      value : Double
      value_in_specified_units : Double
    } derive(Eq, 
    Debug    )

    SVGAngle - represents an angle value with unit
    impl Show for SVGAngle

    SVGAngle::new

    source
    fn SVGAngle::new(value : Double) -> SVGAngle

    Create a new SVGAngle (degrees)

    SVGAngle::to_degrees

    source
    fn SVGAngle::to_degrees(self : SVGAngle) -> Double

    Convert SVGAngle to degrees

    SVGAngle::to_radians

    source
    fn SVGAngle::to_radians(self : SVGAngle) -> Double

    Convert SVGAngle to radians

    SVGAngleType

    source
    pub enum SVGAngleType {
      Unknown
      Unspecified
      Deg
      Rad
      Grad
      Turn
    } derive(Eq, 
    Debug    )

    SVG Angle unit types

    SVGLength

    source
    pub struct SVGLength {
      unit_type : SVGLengthType
      value : Double
      value_in_specified_units : Double
    } derive(Eq, 
    Debug    )

    SVGLength - represents a length value with unit
    impl Show for SVGLength

    SVGLength::new

    source
    fn SVGLength::new(value : Double) -> SVGLength

    Create a new SVGLength (unitless)

    SVGLength::to_user_units

    source
    fn SVGLength::to_user_units(self : SVGLength, dpi? : Double, font_size? : Double) -> Double

    Convert SVGLength to user units (pixels)

    SVGLengthType

    source
    pub enum SVGLengthType {
      Unknown
      Number
      Percentage
      Ems
      Exs
      Px
      Cm
      Mm
      In
      Pt
      Pc
    } derive(Eq, 
    Debug    )

    SVG Length unit types

    SVGMatrix

    source
    pub struct SVGMatrix {
      a : Double
      b : Double
      c : Double
      d : Double
      e : Double
      f : Double
    } derive(Eq, 
    Debug    )

    SVGMatrix - 2D transformation matrix for SVG Represents a 3x3 matrix: | a c e | | b d f | | 0 0 1 |
    impl Show for SVGMatrix

    SVGMatrix::flip_x

    source
    fn SVGMatrix::flip_x(self : SVGMatrix) -> SVGMatrix

    Flip on X axis

    SVGMatrix::flip_y

    source
    fn SVGMatrix::flip_y(self : SVGMatrix) -> SVGMatrix

    Flip on Y axis

    SVGMatrix::identity

    source
    fn SVGMatrix::identity() -> SVGMatrix

    Create an identity matrix

    SVGMatrix::inverse

    source
    fn SVGMatrix::inverse(self : SVGMatrix) -> SVGMatrix?

    Get the inverse of this matrix

    SVGMatrix::multiply

    source
    fn SVGMatrix::multiply(self : SVGMatrix, other : SVGMatrix) -> SVGMatrix

    Multiply this matrix by another matrix (this * other)

    SVGMatrix::new

    source
    fn SVGMatrix::new(a : Double, b : Double, c : Double, d : Double, e : Double, f : Double) -> SVGMatrix

    Create a new SVGMatrix with specified values

    SVGMatrix::rotate

    source
    fn SVGMatrix::rotate(angle : Double) -> SVGMatrix

    Create a rotation matrix (angle in radians)

    SVGMatrix::rotate_deg

    source
    fn SVGMatrix::rotate_deg(angle_deg : Double) -> SVGMatrix

    Create a rotation matrix (angle in degrees)

    SVGMatrix::rotate_self

    source
    fn SVGMatrix::rotate_self(self : SVGMatrix, angle : Double) -> SVGMatrix

    Apply rotation to this matrix (returns new matrix)

    SVGMatrix::scale

    source
    fn SVGMatrix::scale(sx : Double, sy : Double) -> SVGMatrix

    Create a scale matrix

    SVGMatrix::scale_self

    source
    fn SVGMatrix::scale_self(self : SVGMatrix, sx : Double, sy : Double) -> SVGMatrix

    Apply scale to this matrix (returns new matrix)

    SVGMatrix::scale_uniform

    source
    fn SVGMatrix::scale_uniform(s : Double) -> SVGMatrix

    Create a uniform scale matrix

    SVGMatrix::skew_x

    source
    fn SVGMatrix::skew_x(angle : Double) -> SVGMatrix

    Create a skew X matrix (angle in radians)

    SVGMatrix::skew_y

    source
    fn SVGMatrix::skew_y(angle : Double) -> SVGMatrix

    Create a skew Y matrix (angle in radians)

    SVGMatrix::translate

    source
    fn SVGMatrix::translate(tx : Double, ty : Double) -> SVGMatrix

    Create a translation matrix

    SVGMatrix::translate_self

    source
    fn SVGMatrix::translate_self(self : SVGMatrix, tx : Double, ty : Double) -> SVGMatrix

    Apply translation to this matrix (returns new matrix)

    SVGNumber

    source
    pub struct SVGNumber {
      value : Double
    } derive(Eq, 
    Debug    )

    SVGNumber - represents an animated number value
    impl Show for SVGNumber

    SVGNumber::new

    source
    fn SVGNumber::new(value : Double) -> SVGNumber

    Create a new SVGNumber

    SVGPoint

    source
    pub struct SVGPoint {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    SVGPoint - represents a point in SVG coordinate space Has matrixTransform method for coordinate transformations
    impl Show for SVGPoint

    SVGPoint::matrix_transform

    source
    fn SVGPoint::matrix_transform(self : SVGPoint, matrix : SVGMatrix) -> SVGPoint

    Transform this point by a matrix

    SVGPoint::new

    source
    fn SVGPoint::new(x : Double, y : Double) -> SVGPoint

    Create a new SVGPoint

    SVGPoint::origin

    source
    fn SVGPoint::origin() -> SVGPoint

    Create an SVGPoint at origin (0, 0)

    SVGRect

    source
    pub struct SVGRect {
      x : Double
      y : Double
      width : Double
      height : Double
    } derive(Eq, 
    Debug    )

    SVGRect - represents a rectangle in SVG coordinate space Used by getBBox(), getClientRect(), and other SVG methods
    impl Show for SVGRect

    SVGRect::empty

    source
    fn SVGRect::empty() -> SVGRect

    Create an empty SVGRect (0, 0, 0, 0)

    SVGRect::from_rect

    source
    fn SVGRect::from_rect(rect : Rect) -> SVGRect

    Create SVGRect from Rect

    SVGRect::new

    source
    fn SVGRect::new(x : Double, y : Double, width : Double, height : Double) -> SVGRect

    Create a new SVGRect

    SVGRect::to_rect

    source
    fn SVGRect::to_rect(self : SVGRect) -> Rect

    Convert SVGRect to Rect

    SVGTransform

    source
    pub struct SVGTransform {
      transform_type : SVGTransformType
      matrix : SVGMatrix
      angle : Double
    } derive(Eq, 
    Debug    )

    SVGTransform - represents a single transformation

    SVGTransform::from_matrix

    source
    fn SVGTransform::from_matrix(matrix : SVGMatrix) -> SVGTransform

    Create an SVGTransform from a matrix

    SVGTransform::rotate

    source
    fn SVGTransform::rotate(angle : Double, cx? : Double, cy? : Double) -> SVGTransform

    Create a rotate transform (angle in degrees)

    SVGTransform::scale

    source
    fn SVGTransform::scale(sx : Double, sy : Double) -> SVGTransform

    Create a scale transform

    SVGTransform::skew_x

    source
    fn SVGTransform::skew_x(angle : Double) -> SVGTransform

    Create a skewX transform (angle in degrees)

    SVGTransform::skew_y

    source
    fn SVGTransform::skew_y(angle : Double) -> SVGTransform

    Create a skewY transform (angle in degrees)

    SVGTransform::translate

    source
    fn SVGTransform::translate(tx : Double, ty : Double) -> SVGTransform

    Create a translate transform

    SVGTransformType

    source
    pub enum SVGTransformType {
      Unknown
      Matrix
      Translate
      Scale
      Rotate
      SkewX
      SkewY
    } derive(Eq, 
    Debug    )

    SVG Transform types

    ScrollState

    source
    pub struct ScrollState {
      scroll_left : Double
      scroll_top : Double
      scroll_width : Double
      scroll_height : Double
      client_width : Double
      client_height : Double
    } derive(Eq, 
    Debug    )

    Scroll state for a scrollable element
    impl Show for ScrollState

    ScrollState::can_scroll_x

    source
    fn ScrollState::can_scroll_x(self : ScrollState) -> Bool

    Check if horizontal scrolling is possible

    ScrollState::can_scroll_y

    source
    fn ScrollState::can_scroll_y(self : ScrollState) -> Bool

    Check if vertical scrolling is possible

    ScrollState::default

    source
    fn ScrollState::default() -> ScrollState

    Create a default ScrollState (no scrolling)

    ScrollState::max_scroll_left

    source
    fn ScrollState::max_scroll_left(self : ScrollState) -> Double

    Get maximum scroll position (horizontal)

    ScrollState::max_scroll_top

    source
    fn ScrollState::max_scroll_top(self : ScrollState) -> Double

    Get maximum scroll position (vertical)

    ScrollState::new

    source
    fn ScrollState::new(scroll_width : Double, scroll_height : Double, client_width : Double, client_height : Double) -> ScrollState

    Create a new ScrollState

    ScrollState::scroll_by

    source
    fn ScrollState::scroll_by(self : ScrollState, delta_x : Double, delta_y : Double) -> ScrollState

    Scroll by delta (relative scroll)

    ScrollState::scroll_to

    source
    fn ScrollState::scroll_to(self : ScrollState, left : Double, top : Double) -> ScrollState

    Set scroll position (clamped to valid range)

    ShadowRootInit

    source
    pub struct ShadowRootInit {
      mode : String
      delegates_focus : Bool
      slot_assignment : String
      clonable : Bool
      serializable : Bool
    } derive(Eq, 
    Debug    )

    ShadowRootInit::default

    source
    fn ShadowRootInit::default(mode? : String) -> ShadowRootInit

    ShadowRootInit::new

    source
    fn ShadowRootInit::new(mode~ : String, delegates_focus? : Bool, slot_assignment? : String, clonable? : Bool, serializable? : Bool) -> ShadowRootInit

    create_svg_angle

    source
    fn create_svg_angle() -> SVGAngle

    Create a zero SVGAngle

    create_svg_length

    source
    fn create_svg_length() -> SVGLength

    Create a zero SVGLength

    create_svg_matrix

    source
    fn create_svg_matrix() -> SVGMatrix

    Create a new SVGMatrix object (identity matrix) Equivalent to SVGSVGElement.createSVGMatrix()

    create_svg_matrix_with

    source
    fn create_svg_matrix_with(a : Double, b : Double, c : Double, d : Double, e : Double, f : Double) -> SVGMatrix

    Create a new SVGMatrix with values

    create_svg_number

    source
    fn create_svg_number() -> SVGNumber

    Create a zero SVGNumber

    create_svg_point

    source
    fn create_svg_point() -> SVGPoint

    Create a new SVGPoint object Equivalent to SVGSVGElement.createSVGPoint()

    create_svg_point_with

    source
    fn create_svg_point_with(x : Double, y : Double) -> SVGPoint

    Create a new SVGPoint with values

    create_svg_rect

    source
    fn create_svg_rect() -> SVGRect

    Create a new SVGRect object Equivalent to SVGSVGElement.createSVGRect()

    create_svg_rect_with

    source
    fn create_svg_rect_with(x : Double, y : Double, width : Double, height : Double) -> SVGRect

    Create a new SVGRect with values

    create_svg_transform

    source
    fn create_svg_transform() -> SVGTransform

    Create a new SVGTransform

    create_svg_transform_rotate

    source
    fn create_svg_transform_rotate(angle : Double) -> SVGTransform

    Create a rotation SVGTransform

    create_svg_transform_scale

    source
    fn create_svg_transform_scale(sx : Double, sy : Double) -> SVGTransform

    Create a scale SVGTransform

    create_svg_transform_translate

    source
    fn create_svg_transform_translate(tx : Double, ty : Double) -> SVGTransform

    Create a translation SVGTransform

    is_layout_property

    source
    fn is_layout_property(prop : String) -> Bool

    Check if a CSS property affects layout (vs paint-only)

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io