Merge remote-tracking branch 'upstream/master' into dom-bundle

Author: WorldSEnder

packages/yew/src/dom_bundle/blist.rs

@@ -304,22 +304,20 @@ impl BList {
                     // hot path
                     // We know that idx >= run.end_idx, so this node doesn't need to shift
                     Some(run) => run.end_idx = idx,
-                    None => {
-                        match idx.cmp(&barrier_idx) {
-                            // peep hole optimization, don't start a run as the element is already where it should be
-                            Ordering::Equal => barrier_idx += 1,
-                            // shift the node unconditionally, don't start a run
-                            Ordering::Less => writer.shift(&mut r_bundle),
-                            // start a run
-                            Ordering::Greater => {
-                                current_run = Some(RunInformation {
-                                    start_writer: writer.clone(),
-                                    start_idx: replacements.len(),
-                                    end_idx: idx,
-                                })
-                            }
+                    None => match idx.cmp(&barrier_idx) {
+                        // peep hole optimization, don't start a run as the element is already where it should be
+                        Ordering::Equal => barrier_idx += 1,
+                        // shift the node unconditionally, don't start a run
+                        Ordering::Less => writer.shift(&mut r_bundle),
+                        // start a run
+                        Ordering::Greater => {
+                            current_run = Some(RunInformation {
+                                start_writer: writer.clone(),
+                                start_idx: replacements.len(),
+                                end_idx: idx,
+                            })
                         }
-                    }
+                    },
                 }
                 writer = writer.patch(l, &mut r_bundle);
                 r_bundle

packages/yew/src/html/component/lifecycle.rs

@@ -125,9 +125,6 @@ impl<COMP: BaseComponent> Runnable for UpdateRunner<COMP> {
                     RenderRunner {
                         state: self.state.clone(),
                     },
-                    RenderedRunner {
-                        state: self.state.clone(),
-                    },
                 );
                 // Only run from the scheduler, so no need to call `scheduler::start()`
             }
@@ -174,9 +171,24 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
 
                         suspense.resume(m);
                     }
+
                     let scope = state.context.scope.clone().into();
                     let node = state.render_state.reconcile(root, &scope);
                     state.node_ref.link(node);
+
+                    if state.render_state.should_trigger_rendered() {
+                        let first_render = !state.has_rendered;
+                        state.has_rendered = true;
+
+                        scheduler::push_component_rendered(
+                            self.state.as_ptr() as usize,
+                            RenderedRunner {
+                                state: self.state.clone(),
+                                first_render,
+                            },
+                            first_render,
+                        );
+                    }
                 }
 
                 Err(RenderError::Suspended(m)) => {
@@ -192,9 +204,6 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
                             RenderRunner {
                                 state: shared_state.clone(),
                             },
-                            RenderedRunner {
-                                state: shared_state,
-                            },
                         );
                     } else {
                         // We schedule a render after current suspension is resumed.
@@ -212,9 +221,6 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
                                 RenderRunner {
                                     state: shared_state.clone(),
                                 },
-                                RenderedRunner {
-                                    state: shared_state.clone(),
-                                },
                             );
                         }));
 
@@ -234,8 +240,9 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
     }
 }
 
-pub struct RenderedRunner<COMP: BaseComponent> {
-    pub state: Shared<Option<ComponentState<COMP>>>,
+struct RenderedRunner<COMP: BaseComponent> {
+    state: Shared<Option<ComponentState<COMP>>>,
+    first_render: bool,
 }
 
 impl<COMP: BaseComponent> Runnable for RenderedRunner<COMP> {
@@ -244,10 +251,8 @@ impl<COMP: BaseComponent> Runnable for RenderedRunner<COMP> {
             #[cfg(debug_assertions)]
             super::log_event(state.vcomp_id, "rendered");
 
-            if state.suspension.is_none() && state.render_state.should_trigger_rendered() {
-                let first_render = !state.has_rendered;
-                state.component.rendered(&state.context, first_render);
-                state.has_rendered = true;
+            if state.suspension.is_none() {
+                state.component.rendered(&state.context, self.first_render);
             }
         }
     }

packages/yew/src/html/component/scope.rs

@@ -1,8 +1,7 @@
 //! Component scope module
 
 use super::lifecycle::{
-    ComponentState, CreateRunner, DestroyRunner, RenderRunner, RenderedRunner, UpdateEvent,
-    UpdateRunner,
+    ComponentState, CreateRunner, DestroyRunner, RenderRunner, UpdateEvent, UpdateRunner,
 };
 use crate::callback::Callback;
 use crate::context::{ContextHandle, ContextProvider};
@@ -222,9 +221,6 @@ impl<COMP: BaseComponent> Scope<COMP> {
             RenderRunner {
                 state: self.state.clone(),
             },
-            RenderedRunner {
-                state: self.state.clone(),
-            },
         );
         // Not guaranteed to already have the scheduler started
         scheduler::start();

packages/yew/src/lib.rs

@@ -327,7 +327,7 @@ where
     COMP: BaseComponent,
     COMP::Properties: Default,
 {
-    start_app_with_props_in_element(element, COMP::Properties::default())
+    start_app_with_props_in_element::<COMP>(element, COMP::Properties::default())
 }
 
 /// Starts an yew app mounted to the body of the document.
@@ -337,7 +337,7 @@ where
     COMP: BaseComponent,
     COMP::Properties: Default,
 {
-    start_app_with_props(COMP::Properties::default())
+    start_app_with_props::<COMP>(COMP::Properties::default())
 }
 
 /// The main entry point of a Yew application. This function does the
@@ -359,7 +359,7 @@ pub fn start_app_with_props<COMP>(props: COMP::Properties) -> AppHandle<COMP>
 where
     COMP: BaseComponent,
 {
-    start_app_with_props_in_element(
+    start_app_with_props_in_element::<COMP>(
         gloo_utils::document()
             .body()
             .expect("no body node found")
@@ -378,7 +378,7 @@ where
 /// ```
 pub mod prelude {
     pub use crate::callback::Callback;
-    pub use crate::context::ContextProvider;
+    pub use crate::context::{ContextHandle, ContextProvider};
     pub use crate::dom_bundle::AppHandle;
     pub use crate::events::*;
     pub use crate::html::{

packages/yew/src/scheduler.rs

@@ -58,12 +58,10 @@ pub fn push(runnable: Box<dyn Runnable>) {
 pub(crate) fn push_component_create(
     create: impl Runnable + 'static,
     first_render: impl Runnable + 'static,
-    first_rendered: impl Runnable + 'static,
 ) {
     with(|s| {
         s.create.push(Box::new(create));
         s.render_first.push_back(Box::new(first_render));
-        s.rendered_first.push(Box::new(first_rendered));
     });
 }
 
@@ -73,14 +71,25 @@ pub(crate) fn push_component_destroy(runnable: impl Runnable + 'static) {
 }
 
 /// Push a component render and rendered [Runnable]s to be executed
-pub(crate) fn push_component_render(
+pub(crate) fn push_component_render(component_id: usize, render: impl Runnable + 'static) {
+    with(|s| {
+        s.render.schedule(component_id, Box::new(render));
+    });
+}
+
+pub(crate) fn push_component_rendered(
     component_id: usize,
-    render: impl Runnable + 'static,
     rendered: impl Runnable + 'static,
+    first_render: bool,
 ) {
     with(|s| {
-        s.render.schedule(component_id, Box::new(render));
-        s.rendered.schedule(component_id, Box::new(rendered));
+        let rendered = Box::new(rendered);
+
+        if first_render {
+            s.rendered_first.push(rendered);
+        } else {
+            s.rendered.schedule(component_id, rendered);
+        }
     });
 }
 

tools/benchmark-hooks/Cargo.toml

@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 [dependencies]
 rand = { version = "0.8.4", features = ["small_rng"] }
 getrandom = { version = "0.2.1", features = ["js"] }
-wasm-bindgen = "0.2.78"
+wasm-bindgen = "=0.2.78"
 web-sys = { version = "0.3.55", features = ["Window"]}
 yew = "0.19.3"
 

tools/benchmark-struct/Cargo.toml

@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 [dependencies]
 rand = { version = "0.8.4", features = ["small_rng"] }
 getrandom = { version = "0.2.1", features = ["js"] }
-wasm-bindgen = "0.2.78"
+wasm-bindgen = "=0.2.78"
 web-sys = { version = "0.3.55", features = ["Window"]}
 yew = "0.19.3"
 

website/docs/advanced-topics/how-it-works.mdx

@@ -23,16 +23,18 @@ Using the `html!` macro can feel pretty magic, but it has nothing to hide. If yo
 how it works, try expanding the `html!` macro calls in your program. There's a useful command called
 `cargo expand` which allows you to see the expansion of Rust macros. `cargo expand` isn't shipped with
 `cargo` by default so you'll need to install it with `cargo install cargo-expand` if you haven't
-already.
+already. [Rust-Analyzer](https://rust-analyzer.github.io/) also provides a mechanism for
+[obtaining macro output from within an IDE](https://rust-analyzer.github.io/manual.html#expand-macro-recursively).
 
-Note that when viewing expanded macro code, you're likely to encounter unusually verbose code. The
-reason is because generated code can sometimes clash with other code in an application. In order
-to prevent issues, `proc_macro` "hygiene" is adhered to. Some examples include:
+Output from the `html!` macro is often pretty terse! This is a feature: machine-generated code can
+sometimes clash with other code in an application. In order to prevent issues, `proc_macro`
+"hygiene" is adhered to. Some examples include:
 
 1. Instead of using `yew::<module>` the macro generates `::yew::<module>` to make sure that the
 Yew package is referenced correctly. This is also why `::alloc::vec::Vec::new()` is called instead
 of just `Vec::new()`.
-2. Due to potential trait method name collisions, `<Type as Trait>` is used to make sure that we're using items from the right trait.
+2. Due to potential trait method name collisions, `<Type as Trait>` is used to make sure that we're
+using members from the correct trait.
 
 ## What is a virtual DOM?
 

website/docs/advanced-topics/portals.mdx

@@ -3,17 +3,24 @@ title: "Portals"
 description: "Rendering into out-of-tree DOM nodes"
 ---
 
-## How to think about portals?
+## What is a portal?
 
 Portals provide a first-class way to render children into a DOM node that exists outside the DOM hierarchy of the parent component.
 `yew::create_portal(child, host)` returns a `Html` value that renders `child` not hierarchically under its parent component,
 but as a child of the `host` element.
 
 ## Usage
 
-Typical uses of portals can include modal dialogs and hovercards, as well as more technical applications such as controlling the contents of an element's [`shadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/Element/shadowRoot), appending stylesheets to the surrounding document's `<head>` and collecting referenced elements inside a central `<defs>` element of an `<svg>`.
+Typical uses of portals can include modal dialogs and hovercards, as well as more technical applications
+such as controlling the contents of an element's
+[`shadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/Element/shadowRoot), appending
+stylesheets to the surrounding document's `<head>` and collecting referenced elements inside a
+central `<defs>` element of an `<svg>`.
 
-Note that `yew::create_portal` is a rather low-level building block, on which other components should be built that provide the interface for your specific use case. As an example, here is a simple modal dialogue that renders its `children` into an element outside `yew`'s control, identified by the `id="modal_host"`.
+Note that `yew::create_portal` is a low-level building block. Libraries should use it to implement
+higher-level APIs which can then be consumed by applications. For example, here is a
+simple modal dialogue that renders its `children` into an element outside `yew`'s control,
+identified by the `id="modal_host"`.
 
 ```rust
 use yew::{html, create_portal, function_component, Children, Properties, Html};

website/docs/concepts/html/events.mdx

@@ -289,8 +289,8 @@ for the behaviour of `JsCast` but with the smaller scope of events and their tar
 similar to what you would using `JsCast`.
 :::
 
-The `TargetCast` trait builds off of `JsCast` and is specialized towards getting typed event targets
-from events.
+The `TargetCast` trait is built on top of `JsCast` and is specialized towards getting typed event
+targets from events.
 
 `TargetCast` comes with Yew so no need to add a dependency in order to use the trait methods on events
 but it works in a very similar way to `JsCast`.