Feat: include the helper

examples/fc_macro.rs

@@ -20,3 +20,76 @@ fn main() {
 fn example(ctx: &Context, name: String) -> VNode {
     html! { <div> "Hello, {name}!" </div> }
 }
+
+/*
+TODO
+
+/// The macro can also be applied to statics in order to make components less verbose
+/// The FC type automatically adds the inference, and property fields are automatically added as function arguments
+#[fc]
+static Example: FC = |ctx, name: String| {
+    html! { <div> "Hello, {name}!" </div> }
+};
+*/
+
+// This trait is not exposed to users directly, though they could manually implement this for struct-style components
+trait Comp {
+    type Props: Properties;
+    fn render(&self, ctx: &mut Context<Self::Props>) -> VNode;
+    fn builder(&self) -> Self::Props;
+}
+trait Properties {
+    fn new() -> Self;
+}
+
+impl<T: Properties> Comp for FC<T> {
+    type Props = T;
+
+    fn render(&self, ctx: &mut Context<T>) -> VNode {
+        let g = self(ctx);
+        g
+    }
+
+    fn builder(&self) -> T {
+        T::new()
+    }
+}
+
+// impl<T: Properties, F: Fn(&Context<T>) -> VNode> Comp for F {
+//     type Props = T;
+
+//     fn render(&self, ctx: &mut Context<T>) -> VNode {
+//         let g = self(ctx);
+//         g
+//     }
+
+//     fn builder(&self) -> T {
+//         T::new()
+//     }
+// }
+
+impl Properties for () {
+    fn new() -> Self {
+        ()
+    }
+}
+#[allow(unused, non_upper_case_globals)]
+static MyComp: FC<()> = |ctx| {
+    html! {
+        <div>
+        </div>
+    }
+};
+
+fn my_comp(ctx: &Context<()>) -> VNode {
+    todo!()
+}
+
+fn test() {
+    let mut ctx = Context { props: &() };
+    let f = MyComp.render(&mut ctx);
+    let props = MyComp.builder();
+
+    // let f = my_comp.render(&mut ctx);
+    // let props = my_comp.builder();
+}