Struct sauron_core::dom::Program

pub struct Program<APP, MSG>where
    MSG: 'static,{
    pub node_closures: Rc<RefCell<BTreeMap<usize, BTreeMap<&'static str, Closure<dyn FnMut(Event)>>>>>,
    /* private fields */
}

Program handle the lifecycle of the APP

Fields

node_closures: Rc<RefCell<BTreeMap<usize, BTreeMap<&'static str, Closure<dyn FnMut(Event)>>>>>

The closures that are currently attached to all the nodes used in the Application We keep these around so that they don’t get dropped (and thus stop working);

Implementations

impl<APP, MSG> Program<APP, MSG>where MSG: 'static, APP: Application<MSG> + 'static,

A node along with all of the closures that were created for that node’s events and all of it’s child node’s events.

pub fn create_text_node(txt: &str) -> Text

create a text node

pub fn create_dom_node(&self, vnode: &Node<MSG>) -> Node

Create and return a CreatedNode instance (containing a DOM Node together with potentially related closures) for this virtual node.

pub fn dispatch_mount_event(node: &Node)

dispatch the mount event, call the listener since browser don’t allow asynchronous execution of dispatching custom events (non-native browser events)

pub fn append_child_and_dispatch_mount_event(parent: &Node, child_node: &Node)

a helper method to append a node to its parent and trigger a mount event if there is any

pub fn set_element_attributes( &self, element: &Element, attrs: &[&Attribute<MSG>] )

set the element attribute

pub fn set_element_attribute(&self, element: &Element, attr: &Attribute<MSG>)

set the element attribute

Note: this is called in a loop, so setting the attributes, and style will not be on the same call, but on a subsequent call to each other. Using the if-else-if here for attributes, style, function_call.

pub fn add_event_listeners( &self, target: &EventTarget, event_listeners: Vec<Attribute<MSG>> ) -> Result<(), JsValue>

attach and event listener to an event target

pub fn add_event_listener( &self, event_target: &EventTarget, event_name: &str, listener: &Listener<Event, MSG> ) -> Result<Closure<dyn FnMut(Event)>, JsValue>

add a event listener to a target element

pub fn remove_element_attribute( element: &Element, attr: &Attribute<MSG> ) -> Result<(), JsValue>

remove element attribute, takes care of special case such as checked

impl<APP, MSG> Program<APP, MSG>where MSG: 'static, APP: Application<MSG> + 'static,

pub fn convert_patch( &self, nodes_lookup: &BTreeMap<TreePath, Node>, target_element: &Element, patch: &Patch<'_, MSG> ) -> DomPatch<MSG>

convert a virtual DOM Patch into a created DOM node Patch

impl<APP, MSG> Program<APP, MSG>where MSG: 'static,

pub fn downgrade(&self) -> WeakProgram<APP, MSG>

impl<APP, MSG> Program<APP, MSG>where MSG: 'static, APP: Application<MSG> + 'static,

pub fn new( app: APP, mount_node: &Node, action: MountAction, target: MountTarget ) -> Self

Create an Rc wrapped instance of program, initializing DomUpdater with the initial view and root node, but doesn’t mount it yet.

pub fn app(&self) -> Ref<'_, APP>

get a reference to the APP

pub fn mount_node(&self) -> Node

return the node where the app is mounted into

pub fn append_to_mount(app: APP, mount_node: &Node) -> ManuallyDrop<Self>

Instantiage an app and append the view to the root_node

Example

struct App{}
let mount = document().query_selector("#app").ok().flatten().unwrap();
Program::append_to_mount(App{}, &mount);

pub fn replace_mount(app: APP, mount_node: &Node) -> ManuallyDrop<Self>

Creates an Rc wrapped instance of Program and replace the root_node with the app view

Example

struct App{}
let mount = document().query_selector(".container").ok().flatten().unwrap();
Program::replace_mount(App{}, &mount);

pub fn clear_append_to_mount(app: APP, mount_node: &Node) -> ManuallyDrop<Self>

clear the existing children of the mount before mounting the app

pub fn clear_mount(app: APP, mount_node: &Node) -> ManuallyDrop<Self>

clear the existing children of the mount before mounting the app

pub fn clear_mount_to_body(app: APP) -> ManuallyDrop<Self>

clear the existing children of the document body before mounting the app

pub fn mount_to_body(app: APP) -> ManuallyDrop<Self>

Instantiate the app and then append it to the document body

Example

struct App{}
Program::mount_to_body(App{});

pub fn pre_mount(&mut self)

executed right before the app is mounted to the dom

pub fn mount(&mut self)

each element and it’s descendant in the vdom is created into an actual DOM node.

pub fn update_dom( &mut self, modifier: &Modifier ) -> Result<Measurements, JsValue>

update the browser DOM to reflect the APP’s view

pub fn update_dom_with_vdom( &mut self, new_vdom: Node<MSG> ) -> Result<usize, JsValue>

patch the DOM to reflect the App’s view

Note: This is in another function so as to allow tests to use this shared code

pub fn inject_style_to_mount(&mut self, style: &str)

inject style element to the mount node

pub fn dispatch_multiple(&mut self, msgs: impl IntoIterator<Item = MSG>)

dispatch multiple MSG

pub fn dispatch(&mut self, msg: MSG)

dispatch a single msg

impl<APP, MSG> Program<APP, MSG>where MSG: 'static, APP: Application<MSG> + 'static,

pub fn add_window_event_listeners(&self, event_listeners: Vec<Attribute<MSG>>)

attach event listeners to the window

pub fn on_resize<F>(&self, cb: F)where F: FnMut(i32, i32) -> MSG + Clone + 'static,

Creates a Cmd in which the MSG will be emitted whenever the browser is resized

pub fn on_resize_task<F>(cb: F) -> Task<MSG>where F: FnMut(i32, i32) -> MSG + Clone + 'static,

TODO: only executed once, since the Task Future is droped once done TODO: this should be a stream, instead of just one-time future a variant of resize task, but instead of returning Cmd, it is returning Task

pub fn on_hashchange<F>(&self, cb: F)where F: FnMut(String) -> MSG + 'static,

attached a callback and will be triggered when the hash portion of the window location url is changed

Trait Implementations

impl<APP, MSG> Clone for Program<APP, MSG>where MSG: 'static,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<APP, MSG> Drop for Program<APP, MSG>where MSG: 'static,

fn drop(&mut self)

Executes the destructor for this type.