typed-html-0.1.0 doesn't have any documentation.
This crate provides the `html!` macro for building HTML documents inside your
Rust code using roughly [JSX] compatible syntax.
# Nightly Warning!
This crate currently needs nightly rustc, and in order to use it you'll need to
add `#![feature(proc_macro_hygiene)]` to the top of your crate. The compiler
will tell you to do this if you forget. When this feature stabilises, the crate
should work on stable rustc without issues.
# Quick Preview
```
# #![feature(proc_macro_hygiene)]
# use typed_html::{html, for_events};
# use typed_html::dom::{DOMTree, VNode};
# use typed_html::types::Metadata;
# fn main() {
let mut doc: DOMTree"Hello Kitty"
"She is not a cat. She is a human girl."
{ (0..3).map(|_| html!("Her name is Kitty White."
)) }"We still don't know how she eats."
); let doc_str = doc.to_string(); # } ``` # Syntax This macro largely follows [JSX] syntax, but with some differences: * Text nodes must be quoted, because there's only so much Rust's tokeniser can handle outside string literals. So, instead of `Hello
`, you need to write `"Hello"
`. (The parser will throw an error asking you to do this if you forget.) * Element attributes will accept simple Rust expressions, but the parser has its limits, as it's not a full Rust parser. You can use literals, variables, dotted properties, type constructors and single function or method calls. If you use something the parser isn't currently capable of handling, it will complain. You can put braces or parentheses around the expression if the parser doesn't understand it. You can use any Rust code inside a brace or parenthesis block. # Valid HTML5 The macro will only accept valid HTML5 tags, with no tags or attributes marked experimental or obsolete. If it won't accept something you want it to accept, we can discuss it over a pull request (experimental tags and attributes, in particular, are mostly omitted just for brevity, and you're welcome to implement them). The structure validation is simplistic by necessity, as it defers to the type system: a few elements will have one or more required children, and any element which accepts children will have a restriction on the type of the children, usually a broad group as defined by the HTML spec. Many elements have restrictions on children of children, or require a particular ordering of optional elements, which isn't currently validated. # Attribute Values Brace blocks in the attribute value position should return the expected type for the attribute. The type checker will complain if you return an unsupported type. You can also use literals or a few simple Rust expressions as attribute values (see the Syntax section above). The `html!` macro will add an [`.into()`][Into::into] call to the value expression, so that you can use any type that has an [`Into`][Into] trait defined for the actual attribute type `A`. As a special case, if you use a string literal, the macro will instead use the [`FromStr`][FromStr] trait to try and parse the string literal into the expected type. This is extremely useful for eg. CSS classes, letting you type `class="css-class-1 css-class-2"` instead of going to the trouble of constructing a [`SpacedSet
// parses a string literal
// uses From<[&str, &str, &str]>
// uses a variable in scope
)
# ;}
```
# Generated Nodes
Brace blocks in the child node position are expected to return an
[`IntoIterator`][IntoIterator] of [`DOMTree`][DOMTree]s. You can return single
elements or text nodes, as they both implement `IntoIterator` for themselves.
The macro will consume this iterator at runtime and insert the generated nodes
as children in the expected position.
## Example
```
# #![feature(proc_macro_hygiene)]
# use typed_html::{html, text};
# use typed_html::dom::DOMTree;
# fn main() {
# let doc: DOMTree-
{ (1..=5).map(|i| html!(
- { text!("{}", i) } )) }
"Hello Kitty"
); let doc_str = doc.to_string(); assert_eq!("Hello Kitty
", doc_str); # } ``` ## Render to a virtual DOM The DOM tree structure also implements a method called `vnode()`, which renders the tree to a tree of [`Node`][Node]s, which is a mirror of the generated tree with every attribute value rendered into `String`s. You can walk this virtual DOM tree and use it to build an actual DOM tree with `stdweb` or pass it on to your favourite virtual DOM system. # Licence Copyright 2018 Bodil Stokke This software is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at