Start work on v0.19 (#49)

* Try out new design

* Impl View for tuples

* Create use_ref hook

* Re-import web code and refactor

* Clean up

Cargo.toml

@@ -3,6 +3,6 @@ resolver = "2"
 members = [
  "crates/concoct",
  "crates/concoct-web",
- "crates/concoct-menu",
+ # "crates/concoct-menu",
  "web_examples/counter"
 ]

crates/concoct-web/Cargo.toml

@@ -10,3 +10,4 @@ repository = "https://github.com/concoct-rs/concoct"
 # concoct = "0.17.0-alpha.2"
 concoct = { path = "../concoct" }
 web-sys = { version = "0.3.66", features = ["Document", "Event", "HtmlElement", "HtmlCollection", "Text", "Window"] }
+rustc-hash = "1.1.0"

crates/concoct-web/src/html.rs

@@ -1,19 +1,19 @@
-use super::WebContext;
 use concoct::{
- hook::{use_context, use_on_drop, use_provider, use_ref},
- view::ViewCell,
- View, ViewBuilder,
+ hook::{use_context, use_provider, use_ref},
+ View,
 };
-use std::{borrow::Cow, cell::RefCell, rc::Rc};
+use std::{borrow::Cow, cell::RefCell, marker::PhantomData, rc::Rc};
 use web_sys::{
  wasm_bindgen::{closure::Closure, JsCast},
  Element, Event,
 };
 
+use crate::WebContext;
+
 macro_rules! make_tag_fns {
  ($($name:tt),*) => {
  $(
- pub fn $name<C: View>(content: C) -> Html<C> {
+ pub fn $name<T, A, C: View<T, A>>(content: C) -> Html<C, T, A> {
  Html::new(stringify!($name), content)
  }
  )*
@@ -40,11 +40,12 @@ struct Data {
  )>,
 }
 
-pub struct Html<C> {
+pub struct Html<C, T, A> {
  tag: Cow<'static, str>,
  attrs: Vec<(Cow<'static, str>, Cow<'static, str>)>,
  handlers: Vec<(Cow<'static, str>, Rc<RefCell<dyn FnMut(Event)>>)>,
- content: ViewCell<C>,
+ content: C,
+ _marker: PhantomData<(T, A)>,
 }
 
 macro_rules! impl_attr_methods {
@@ -67,16 +68,17 @@ macro_rules! impl_handler_methods {
  };
 }
 
-impl<C> Html<C> {
- pub fn new(tag: impl Into<Cow<'static, str>>, content: C) -> Html<C>
+impl<C, T, A> Html<C, T, A> {
+ pub fn new(tag: impl Into<Cow<'static, str>>, content: C) -> Html<C, T, A>
  where
- C: View,
+ C: View<T, A>,
  {
  Html {
  tag: tag.into(),
  attrs: Vec::new(),
  handlers: Vec::new(),
- content: ViewCell::new(content),
+ content,
+ _marker: PhantomData,
  }
  }
 
@@ -111,19 +113,24 @@ impl<C> Html<C> {
  );
 }
 
-impl<C: View> ViewBuilder for Html<C> {
- fn build(&self) -> impl View {
- let data = use_ref(|| RefCell::new(Data::default()));
+impl<T, A, C> View<T, A> for Html<C, T, A>
+where
+ C: View<T, A>,
+{
+ fn body(&mut self, cx: &concoct::Scope<T, A>) -> impl View<T, A> {
+ let data = use_ref(cx, || Rc::new(RefCell::new(Data::default())));
  let mut data_ref = data.borrow_mut();
 
- let web_cx = use_context::<WebContext>().unwrap();
- let data_clone = data.clone();
+ let web_cx: Rc<WebContext> = use_context(cx);
+ let _data_clone = data.clone();
 
- use_on_drop(move || {
+ /*
+ use_on_drop(move || {
  if let Some(element) = &data_clone.borrow_mut().element {
  element.remove();
  }
  });
+ */
 
  if data_ref.element.is_none() {
  let elem = web_cx.document.create_element(&self.tag).unwrap();
@@ -155,12 +162,13 @@ impl<C: View> ViewBuilder for Html<C> {
  }
  }
 
- use_provider(WebContext {
+ use_provider(cx, || WebContext {
  window: web_cx.window.clone(),
  document: web_cx.document.clone(),
- parent: data_ref.element.as_ref().unwrap().clone().into(),
+ body: web_cx.body.clone(),
+ parent: data_ref.element.as_ref().unwrap().clone().unchecked_into(),
  });
 
- self.content.clone()
+ &mut self.content
  }
 }

crates/concoct-web/src/lib.rs

@@ -1,66 +1,74 @@
 use concoct::{
- hook::{use_context, use_on_drop, use_provider, use_ref},
- TextViewContext, View, ViewBuilder,
+ hook::{use_context, use_provider, use_ref},
+ Scope, TextViewContext, View,
 };
-use std::{cell::RefCell, rc::Rc};
-use web_sys::{Document, Node, Text, Window};
+use rustc_hash::FxHasher;
+use std::{
+ cell::Cell,
+ hash::{Hash, Hasher},
+ rc::Rc,
+};
+use web_sys::{Document, HtmlElement, Window};
 
 pub mod html;
 
 struct WebContext {
  window: Window,
  document: Document,
- parent: Node,
+ body: HtmlElement,
+ parent: HtmlElement,
 }
 
-struct WebRoot<VB> {
- pub body: Rc<VB>,
+pub struct HtmlRoot<C> {
+ content: C,
 }
 
-impl<VB: ViewBuilder> ViewBuilder for WebRoot<VB> {
- fn build(&self) -> impl View {
- let window = web_sys::window().unwrap();
- let document = window.document().unwrap();
- let body = document.body().unwrap();
-
- use_provider(WebContext {
- window,
- document,
- parent: body.into(),
+impl<T: 'static, A: 'static, C: View<T, A>> View<T, A> for HtmlRoot<C> {
+ fn body(&mut self, cx: &Scope<T, A>) -> impl View<T, A> {
+ use_provider(cx, || {
+ let window = web_sys::window().unwrap();
+ let document = window.document().unwrap();
+ let body = document.body().unwrap();
+ WebContext {
+ window,
+ document,
+ body: body.clone(),
+ parent: body,
+ }
  });
 
- use_provider(TextViewContext::new(|s| {
- let web_cx = use_context::<WebContext>().unwrap();
+ use_provider(cx, || {
+ TextViewContext::new(|cx: &Scope<T, A>, s| {
+ let web_cx: Rc<WebContext> = use_context(cx);
 
- let data = use_ref(|| RefCell::new((s.clone(), None::<Text>)));
- let (last, node_cell) = &mut *data.borrow_mut();
+ let mut is_init = false;
+ let (hash_cell, node) = use_ref(cx, || {
+ let elem = web_cx.document.create_text_node(s);
+ web_cx.parent.append_child(&elem).unwrap();
 
- let data_clone = data.clone();
- use_on_drop(move || {
- if let Some(node) = &data_clone.borrow_mut().1 {
- node.remove();
- }
- });
+ let mut hasher = FxHasher::default();
+ s.hash(&mut hasher);
+ let hash = hasher.finish();
+
+ is_init = true;
+ (Cell::new(hash), elem)
+ });
+
+ if !is_init {
+ let mut hasher = FxHasher::default();
+ s.hash(&mut hasher);
+ let hash = hasher.finish();
 
- if let Some(node) = node_cell {
- if s != *last {
- node.set_text_content(Some(&s));
- *last = s.clone();
+ let last_hash = hash_cell.get();
+ hash_cell.set(hash);
+
+ if hash != last_hash {
+ node.set_text_content(Some(s));
+ }
  }
- } else {
- let node = web_cx.document.create_text_node(&s);
- web_cx.parent.append_child(&node).unwrap();
- *node_cell = Some(node);
- }
- }));
+ })
+ });
 
- self.body.clone()
+ &mut self.content
  }
 }
-
-pub async fn run(view: impl ViewBuilder) {
- concoct::run(WebRoot {
- body: Rc::new(view),
- })
- .await;
-}

crates/concoct/examples/app.rs

@@ -0,0 +1,24 @@
+use concoct::{Scope, View, VirtualDom};
+
+struct Child;
+
+impl View<Counter> for Child {
+ fn body(&mut self, cx: &Scope<Counter>) -> impl View<Counter> {
+ dbg!(cx.key);
+ }
+}
+
+struct Counter;
+
+impl View<Self> for Counter {
+ fn body(&mut self, _cx: &Scope<Self>) -> impl View<Self> {
+ dbg!("view");
+ (Child, Child)
+ }
+}
+
+fn main() {
+ let mut app = VirtualDom::new(Counter);
+ app.build();
+ app.rebuild();
+}

crates/concoct/src/hook/mod.rs

@@ -1,16 +1,8 @@
-//! Hooks to access render context.
-
 mod use_context;
-pub use use_context::{use_context, use_provider};
+pub use self::use_context::use_context;
 
-mod use_effect;
-pub use self::use_effect::use_effect;
+mod use_provider;
+pub use self::use_provider::use_provider;
 
 mod use_ref;
-pub use use_ref::use_ref;
-
-mod use_state;
-pub use use_state::use_state;
-
-mod use_on_drop;
-pub use use_on_drop::use_on_drop;
+pub use self::use_ref::use_ref;

crates/concoct/src/hook/use_context.rs

@@ -1,26 +1,8 @@
-use crate::Runtime;
+use crate::Scope;
 use std::{any::TypeId, rc::Rc};
 
-/// Hook to provide a context.
-pub fn use_provider<T: 'static>(value: T) {
- let cx = Runtime::current();
- let cx_ref = cx.inner.borrow();
- let mut scope = cx_ref.scope.as_ref().unwrap().inner.borrow_mut();
-
- scope.contexts.insert(TypeId::of::<T>(), Rc::new(value));
-}
-
-/// Hook to get a context from its type.
-pub fn use_context<T: 'static>() -> Option<Rc<T>> {
- Runtime::current()
- .inner
- .borrow()
- .scope
- .as_ref()
- .unwrap()
- .inner
- .borrow()
- .contexts
- .get(&TypeId::of::<T>())
- .map(|rc| Rc::downcast(rc.clone()).unwrap())
+pub fn use_context<T, A, R: 'static>(cx: &Scope<T, A>) -> Rc<R> {
+ let contexts = cx.contexts.borrow();
+ let rc = contexts.get(&TypeId::of::<R>()).unwrap();
+ Rc::downcast(rc.clone()).unwrap()
 }

crates/concoct/src/hook/use_provider.rs

@@ -0,0 +1,12 @@
+use crate::Scope;
+use std::{any::TypeId, rc::Rc};
+
+use super::use_ref;
+
+pub fn use_provider<T, A, R: 'static>(cx: &Scope<T, A>, make_initial: impl FnOnce() -> R) {
+ use_ref(cx, || {
+ cx.contexts
+ .borrow_mut()
+ .insert(TypeId::of::<R>(), Rc::new(make_initial()))
+ });
+}