Crate sauron

source ·
Expand description

Sauron is an web framework for creating fast and interactive client side web application, as well as server-side rendering for back-end web applications.

Modules§

  • diff
    provides diffing algorithm which returns patches
  • dom
    This module provides functionalities for manipulating the actual Document Object Model in the browser
  • html
    Provides functions and macros to build html elements
  • prelude
    prelude
  • serde_wasm_bindgen
    This is a native integration of Serde with wasm-bindgen. It allows to convert Rust data types into native JavaScript types and vice versa.
  • svg
    Provides functions and macros to build svg elements
  • vdom
    vdom stands for virtual-dom. This module contains types that are derived from mt-dom where we assign concrete types into the generics.
  • wasm_bindgen_futures
    Converting between JavaScript Promises to Rust Futures.
  • web_sys
    Raw API bindings for Web APIs

Macros§

  • declare_attributes
    declare a function with the name corresponds to attribute name for easy usage in html elements Example:
  • extract_skip_diff
    Generate a skip diff list based on the node used in the view
  • extract_template
    extract template by including only attributes and elements that is static str
  • jss
    build a css string
  • jss_with_media
    build css string that has media selector or any other conditional group
  • key
    creates a key attribute using a formatter
  • node
    Quasi-quoting macro for building sauron Nodes.
  • style
    build a style attribute
  • text
    creates a text node using a formatter
  • view

Structs§

  • AnimationEvent
    The AnimationEvent class.
  • AnimationFrameHandle
    request animation frame handle
  • Attribute
    These are the plain attributes of an element
  • Closure
    A handle to both a closure in Rust as well as JS closure which will invoke the Rust closure.
  • Cmd
    Cmd is a way to tell the Runtime that something needs to be executed
  • Dispatch
    Dispatch is a command to be executed by the system. This is returned at the init function of a component and is executed right after instantiation of that component. Dispatch required a DSP object which is the Program as an argument The emit function is called with the program argument. The callback is supplied with the program an is then executed/emitted.
  • Document
    Provides function for document related functions
  • Effects
    Effects is a convenient way to group Msg for component to execute subsequent updates based on certain conditions. This can be used for doing animation and incremental changes to the view to provide an effect of transition or animation.
  • Element
    Represents an element of the virtual node An element has a generic tag, this tag could be a static str tag, such as usage in html dom. Example of which are div, a, input, img, etc.
  • FocusEvent
    The FocusEvent class.
  • HashChangeEvent
    The HashChangeEvent class.
  • InputEvent
    TODO: expand this much farther by getting the InputEvent data, data_transfer, event_type, is_composing events. a custom InputEvent to contain the input string value
  • JsError
    Convenience type for use on exported fn() -> Result<T, JsError> functions, where you wish to throw a JavaScript Error object.
  • JsValue
    Representation of an object owned by JS.
  • KeyboardEvent
    The KeyboardEvent class.
  • Measurements
    Contains the time it took for the last app update call for the component TODO: Maybe rename to Diagnostics
  • MountEvent
    an event when a virtual Node is mounted the field node is the actual dom node where the virtual Node is created in the actual dom
  • MouseEvent
    The MouseEvent class.
  • Patch
    A Patch encodes an operation that modifies a real DOM element or native UI element
  • Program
    Program handle the lifecycle of the APP
  • Selection
    The Selection class.
  • SkipDiff
    if the expression evaluates to true, diffing at this node will be skipped entirely
  • Time
    Provides function related to Time
  • TimeoutCallbackHandle
    handle for request_idle_callback calls
  • TouchEvent
    The TouchEvent class.
  • TransitionEvent
    The TransitionEvent class.
  • TreePath
    Describe the path traversal of a Node starting from the root node
  • WebComponentWrapper
    A self contain web component This is needed to move some of the code from the #custom_element macro This is also necessary, since #[wasm_bindgen] macro can not process impl types which uses generics, we use generics here to simplify the code and do the type checks for us, rather than in the code derived from the #[web_component] macro
  • Window
    Provides function for window related functions

Enums§

  • AttributeValue
    Values of an attribute can be in these variants
  • DomAttrValue
    a dom version of the Attribute value, thereby removing the MSG generic
  • MountAction
    specify how the App is mounted to the DOM
  • MountTarget
    specify whether to attach the Node in shadow_root
  • MouseButton
    Mouse button used in the MouseEvent
  • Node
    represents a node in a virtual dom A node could be an element which can contain one or more children of nodes. A node could also be just a text node which contains a string
  • Value
    Wraps different primitive variants used as values in html This is needed since html attributes can have different value types such as checked(bool), name(String), tab_index(i32) Note: memory size of Value is 32 bytes, in comparison String is 24 bytes

Constants§

  • HTML_ATTRS
    These are most commonly used html attributes such as class, id, etc
  • HTML_EVENTS
    html events
  • HTML_TAGS
    These are the comonly used html tags such as div, input, buttons,.. etc
  • SVG_ATTRS
    These are most commonly used svg attributes
  • SVG_ATTRS_SPECIAL
    These are svg attributes with names that are non proper rust identifier therefore they are handled differently. ie: (color-profile, accent-height, etc)
  • SVG_ATTRS_XLINK
    Svg attributes with xlink namespace
  • SVG_TAGS
    These are the commonly used svg tags such as rect, circle, path, arc, ..etc.
  • SVG_TAGS_SPECIAL
    These are svg tags which the tags are non proper rust identifier, so they are handled differently

Traits§

  • Application
    An Application is the root component of your program. Everything that happens in your application is done here.
  • Component
    A component has a view and can update itself.
  • JsCast
    A trait for checked and unchecked casting between JS types.
  • StatefulComponent
    A component that can be used directly in the view without mapping
  • UnwrapThrowExt
    An extension trait for Option<T> and Result<T, E> for unwrapping the T value, or throwing a JS error if it is not available.
  • WebComponent
    a trait for implementing WebComponent in the DOM with custom tag

Functions§

Type Aliases§

  • EventCallback
    Callback where Event type is supplied for Components

Attribute Macros§

  • __wasm_bindgen_class_marker
  • custom_element
    derive code for a certain CustomElement implementation to have the necessary types and glue code which register itself into the the DOM customElementRegistry. This also adds the register function into the module it is called in, so make sure you only use this in each module, multiple web_components should be in different modules
  • wasm_bindgen