lampclaw/moonstyle/runtime does not have a README file

    StyleResult

    The result of an operation that can fail: either Ok(value) or Err(error).

    StaticStyleInput

    pub(open) trait StaticStyleInput {
    fn to_compiled(Self) -> CompiledStyle
    }

    StyleInput

    pub(open) trait StyleInput {
    fn append_to(Self, StyleList) -> StyleList
    }

    impl StyleInput for Option[T]
    impl StyleInput for Array[T]

    AppliedStyle

    pub(all) struct AppliedStyle {
    class_name : String
    inline_vars : Array[(String, String)]
    } derive(Eq,
    Debug
    )

    AppliedStyle::equal

    AppliedStyle::not_equal

    fn AppliedStyle::not_equal(x : AppliedStyle, y : AppliedStyle) -> Bool

    CompiledStyle

    pub struct CompiledStyle {
    entries : Array[(String, String?)]
    inline_vars : Array[(String, String)]
    }

    CompiledStyle::append_to

    fn CompiledStyle::append_to(self : CompiledStyle, list : StyleList) -> StyleList

    CompiledStyle::to_compiled

    fn CompiledStyle::to_compiled(self : CompiledStyle) -> CompiledStyle

    CompiledStyle::when

    fn CompiledStyle::when(self : CompiledStyle, enabled : Bool) -> CompiledStyle

    DynamicValueError

    pub(all) struct DynamicValueError {
    variable : String
    code : String
    label : String
    } derive(Eq,
    Debug
    )

    DynamicValueError::equal

    DynamicValueError::not_equal

    fn DynamicValueError::not_equal(x : DynamicValueError, y : DynamicValueError) -> Bool

    SelectorMarker

    pub struct SelectorMarker {
    module_name : String
    name : String
    class_name : String
    compiled : CompiledStyle
    }

    A generated marker is both a style input (it applies its stable marker class) and a typed selector identity consumable by relational conditions.

    SelectorMarker::append_to

    fn SelectorMarker::append_to(self : SelectorMarker, list : StyleList) -> StyleList

    SelectorMarker::class_name

    fn SelectorMarker::class_name(self : SelectorMarker) -> String

    SelectorMarker::module_name

    fn SelectorMarker::module_name(self : SelectorMarker) -> String

    SelectorMarker::name

    fn SelectorMarker::name(self : SelectorMarker) -> String

    SelectorMarker::to_compiled

    fn SelectorMarker::to_compiled(self : SelectorMarker) -> CompiledStyle

    StyleList

    pub struct StyleList {
    styles : Array[CompiledStyle]
    errors : Array[DynamicValueError]
    }

    StyleList::add

    fn[T : StyleInput] StyleList::add(self : StyleList, input : T) -> StyleList

    StyleList::append_to

    fn StyleList::append_to(self : StyleList, list : StyleList) -> StyleList

    StyleList::resolve

    StyleList::when

    fn[T : StyleInput] StyleList::when(self : StyleList, enabled : Bool, input : T) -> StyleList

    checked_when

    fn checked_when(style : Result[CompiledStyle, Array[DynamicValueError]], enabled : Bool) -> Result[CompiledStyle, Array[DynamicValueError]]

    compiled

    fn compiled(entries : Array[(String, String)], inline_vars? : Array[(String, String)]) -> CompiledStyle

    compiled_v2

    fn compiled_v2(entries : Array[(String, String?)], inline_vars? : Array[(String, String)]) -> CompiledStyle

    compiled_v3

    fn compiled_v3(entries : Array[(String, String?)], inline_vars? : Array[(String, String)]) -> CompiledStyle

    compiled_v5

    fn compiled_v5(entries : Array[(String, String?)], inline_vars? : Array[(String, String)]) -> CompiledStyle

    compose

    fn[T : StyleInput] compose(initial : T) -> StyleList

    dynamic_value_error

    fn dynamic_value_error(variable : String, code : String, label : String) -> DynamicValueError

    expect_dynamic

    fn[T] expect_dynamic(result : Result[T, Array[DynamicValueError]]) -> T

    none

    let none : CompiledStyle

    props

    fn[T : StaticStyleInput] props(styles : Array[T]) -> AppliedStyle

    props_checked

    fn props_checked(checked_styles : Array[Result[CompiledStyle, Array[DynamicValueError]]], base_styles? : Array[CompiledStyle]) -> Result[AppliedStyle, Array[DynamicValueError]]

    selector_marker

    fn selector_marker(module_name : String, name : String, class_name : String) -> SelectorMarker

    style_list

    fn style_list() -> StyleList

    styles

    #deprecated("Use compose(input) for a non-empty composition or style_list() for an empty composition")
    fn[T : StyleInput] styles(initial : Array[T]) -> StyleList

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io