Struct Program

pub struct Program<APP>
where
    APP: Application,
{
    pub root_node: Rc<RefCell<Option<DomNode>>>,
    /* private fields */
}

Program handle the lifecycle of the APP

Fields

root_node: Rc<RefCell<Option<DomNode>>>

the first element of the app view, where the patch is generated is relative to

Implementations

impl<APP> Program<APP>

where APP: Application + 'static,

pub fn create_dom_node(&self, node: &Node<<APP as Application>::MSG>) -> DomNode

Create a dom node

impl<APP> Program<APP>

where APP: Application + 'static,

pub fn convert_patch( &self, nodes_lookup: &IndexMap<TreePath, (DomNode, DomNode)>, target_element: &DomNode, target_parent: &DomNode, patch: &Patch<'_, <APP as Application>::MSG>, ) -> DomPatch

convert a virtual DOM Patch into a created DOM node Patch

impl<APP> Program<APP>

where APP: Application,

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

impl<APP> Program<APP>

where APP: Application,

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

get a reference to the APP

pub fn app_mut(&self) -> RefMut<'_, APP>

get a mutable reference to the APP

impl<APP> Program<APP>

where APP: Application,

pub fn new(app: APP) -> Program<APP>

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

pub fn from_rc_app(app: Rc<RefCell<APP>>) -> Program<APP>

create a program from Rc<RefCell>

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

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<Program<APP>>

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<Program<APP>>

clear the existing children of the mount before mounting the app

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

clear the existing children of the mount before mounting the app

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

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

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

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, mount_node: &Node, mount_procedure: MountProcedure)

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

pub fn update_dom(&mut self) -> Result<(), JsValue>

execute DOM changes in order to reflect the APP’s view into the browser representation

pub fn queue_dom_patches( &mut self, dom_patches: Vec<DomPatch>, ) -> Result<(), 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 = <APP as Application>::MSG>, )

dispatch multiple MSG

pub fn dispatch(&mut self, msg: <APP as Application>::MSG)

dispatch a single msg

pub fn create_dom_patch( &self, new_vdom: &Node<<APP as Application>::MSG>, ) -> Vec<DomPatch>

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

impl<APP> Program<APP>

where APP: Application,

pub fn update_dom_with_vdom( &mut self, new_vdom: Node<<APP as Application>::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

Trait Implementations

impl<APP> Clone for Program<APP>

where APP: Application,

fn clone(&self) -> Program<APP>

Returns a copy of the value.

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

Performs copy-assignment from source.