Internationalization: move guide to en folder and preserve its history. (#494)

* chore: move guide to en folder

* docs: add english as language

docs/guide/src/en/describing_ui/component_children.md

@@ -0,0 +1,31 @@
+# Component Children
+
+In some cases, you may wish to create a component that acts as a container for some other content, without the component needing to know what that content is. To achieve this, create a prop of type `Element`:
+
+```rust
+{{#include ../../examples/component_element_props.rs:Clickable}}
+```
+
+Then, when rendering the component, you can pass in the output of `cx.render(rsx!(...))`:
+
+```rust
+{{#include ../../examples/component_element_props.rs:Clickable_usage}}
+```
+
+> Note: Since `Element<'a>` is a borrowed prop, there will be no memoization.
+
+> Warning: While it may compile, do not include the same `Element` more than once in the RSX. The resulting behavior is unspecified.
+
+## The `children` field
+
+Rather than passing the RSX through a regular prop, you may wish to accept children similarly to how elements can have children. The "magic" `children` prop lets you achieve this:
+
+```rust
+{{#include ../../examples/component_children.rs:Clickable}}
+```
+
+This makes using the component much simpler: simply put the RSX inside the `{}` brackets – and there is no need for a `render` call or another macro!
+
+```rust
+{{#include ../../examples/component_children.rs:Clickable_usage}}
+```

docs/guide/src/en/describing_ui/component_props.md

@@ -0,0 +1,141 @@
+# Component Props
+
+Just like you can pass arguments to a function, you can pass props to a component that customize its behavior! The components we've seen so far didn't accept any props – so let's write some components that do.
+
+## `#[derive(Props)]`
+
+Component props are a single struct annotated with `#[derive(Props)]`. For a component to accept props, the type of its argument must be `Scope<YourPropsStruct>`. Then, you can access the value of the props using `cx.props`.
+
+There are 2 flavors of Props structs:
+- Owned props:
+  - Don't have an associated lifetime
+  - Implement `PartialEq`, allowing for memoization (if the props don't change, Dioxus won't re-render the component)
+- Borrowed props:
+  - [Borrow](https://doc.rust-lang.org/beta/rust-by-example/scope/borrow.html) from a parent component
+  - Cannot be memoized due to lifetime constraints
+
+
+### Owned Props
+
+Owned Props are very simple – they don't borrow anything. Example:
+
+```rust
+{{#include ../../examples/component_owned_props.rs:Likes}}
+```
+
+You can then pass prop values to the component the same way you would pass attributes to an element:
+```rust
+{{#include ../../examples/component_owned_props.rs:App}}
+```
+
+![Screenshot: Likes component](./images/component_owned_props_screenshot.png)
+
+### Borrowed Props
+
+Owning props works well if your props are easy to copy around – like a single number. But what if we need to pass a larger data type, like a String from an `App` Component to a `TitleCard` subcomponent? A naive solution might be to [`.clone()`](https://doc.rust-lang.org/std/clone/trait.Clone.html) the String, creating a copy of it for the subcomponent – but this would be inefficient, especially for larger Strings.
+
+Rust allows for something more efficient – borrowing the String as a `&str` – this is what Borrowed Props are for!
+
+```rust
+{{#include ../../examples/component_borrowed_props.rs:TitleCard}}
+```
+
+We can then use the component like this:
+
+```rust
+{{#include ../../examples/component_borrowed_props.rs:App}}
+```
+![Screenshot: TitleCard component](./images/component_borrowed_props_screenshot.png)
+
+
+## Prop Options
+
+The `#[derive(Props)]` macro has some features that let you customize the behavior of props.
+
+### Optional Props
+
+You can create optional fields by using the `Option<…>` type for a field:
+
+```rust
+{{#include ../../examples/component_props_options.rs:OptionalProps}}
+```
+
+Then, you can choose to either provide them or not:
+
+```rust
+{{#include ../../examples/component_props_options.rs:OptionalProps_usage}}
+```
+
+### Explicitly Required `Option`s
+
+If you want to explicitly require an `Option`, and not an optional prop, you can annotate it with `#[props(!optional)]`:
+
+```rust
+{{#include ../../examples/component_props_options.rs:ExplicitOption}}
+```
+
+Then, you have to explicitly pass either `Some("str")` or `None`:
+
+```rust
+{{#include ../../examples/component_props_options.rs:ExplicitOption_usage}}
+```
+
+### Default Props
+
+You can use `#[props(default = 42)]` to make a field optional and specify its default value:
+
+```rust
+{{#include ../../examples/component_props_options.rs:DefaultComponent}}
+```
+
+Then, similarly to optional props, you don't have to provide it:
+
+```rust
+{{#include ../../examples/component_props_options.rs:DefaultComponent_usage}}
+```
+
+### Automatic Conversion with `.into`
+
+It is common for Rust functions to accept `impl Into<SomeType>` rather than just `SomeType` to support a wider range of parameters. If you want similar functionality with props, you can use `#[props(into)]`. For example, you could add it on a `String` prop – and `&str` will also be automatically accepted, as it can be converted into `String`:
+
+```rust
+{{#include ../../examples/component_props_options.rs:IntoComponent}}
+```
+
+Then, you can use it so:
+
+```rust
+{{#include ../../examples/component_props_options.rs:IntoComponent_usage}}
+```
+
+## The `inline_props` macro
+
+So far, every Component function we've seen had a corresponding ComponentProps struct to pass in props. This was quite verbose... Wouldn't it be nice to have props as simple function arguments? Then we wouldn't need to define a Props struct, and instead of typing `cx.props.whatever`, we could just use `whatever` directly!
+
+`inline_props` allows you to do just that. Instead of typing the "full" version:
+
+```rust
+#[derive(Props, PartialEq)]
+struct TitleCardProps {
+    title: String,
+}
+
+fn TitleCard(cx: Scope<TitleCardProps>) -> Element {
+    cx.render(rsx!{
+        h1 { "{cx.props.title}" }
+    })
+}
+```
+
+...you can define a function that accepts props as arguments. Then, just annotate it with `#[inline_props]`, and the macro will turn it into a regular Component for you:
+
+```rust
+#[inline_props]
+fn TitleCard(cx: Scope, title: String) -> Element {
+    cx.render(rsx!{
+        h1 { "{title}" }
+    })
+}
+```
+
+> While the new Component is shorter and easier to read, this macro should not be used by library authors since you have less control over Prop documentation.

docs/guide/src/en/describing_ui/components.md

@@ -0,0 +1,27 @@
+# Components
+
+Just like you wouldn't want to write a complex program in a single, long, `main` function, you shouldn't build a complex UI in a single `App` function. Instead, it would be better to break down the functionality of an app in logical parts called components.
+
+A component is a Rust function, named in UpperCammelCase, that takes a `Scope` parameter and returns an `Element` describing the UI it wants to render. In fact, our `App` function is a component!
+
+```rust
+{{#include ../../examples/hello_world_desktop.rs:component}}
+```
+
+> You'll probably want to add `#![allow(non_snake_case)]` to the top of your crate to avoid warnings about the function name
+
+A Component is responsible for some rendering task – typically, rendering an isolated part of the user interface. For example, you could have an `About` component that renders a short description of Dioxus Labs:
+
+```rust
+{{#include ../../examples/components.rs:About}}
+```
+
+Then, you can render your component in another component, similarly to how elements are rendered:
+
+```rust
+{{#include ../../examples/components.rs:App}}
+```
+
+![Screenshot containing the About component twice](./images/screenshot_about_component.png)
+
+> At this point, it might seem like components are nothing more than functions. However, as you learn more about the features of Dioxus, you'll see that they are actually more powerful!

docs/guide/src/en/describing_ui/index.md

@@ -0,0 +1,106 @@
+# Describing the UI
+
+Dioxus is a *declarative* framework. This means that instead of telling Dioxus what to do (e.g. to "create an element" or "set color to red") we simply *declare* what we want the UI to look like using RSX.
+
+You have already seen a simple example or RSX syntax in the "hello world" application:
+
+```rust
+{{#include ../../examples/hello_world_desktop.rs:component}}
+```
+
+Here, we use the `rsx!` macro to *declare* that we want a `div` element, containing the text `"Hello, world!"`. Dioxus takes the RSX and constructs a UI from it.
+
+## RSX Features
+
+RSX is very similar to HTML in that it describes elements with attributes and children. Here's an empty `div` element in RSX, as well as the resulting HTML:
+
+```rust
+{{#include ../../examples/rsx_overview.rs:empty}}
+```
+```html
+<div></div>
+```
+
+### Children
+
+To add children to an element, put them inside the `{}` brackets. They can be either other elements, or text. For example, you could have an `ol` (ordered list) element, containing 3 `li` (list item) elements, each of which contains some text: 
+
+```rust
+{{#include ../../examples/rsx_overview.rs:children}}
+```
+```html
+<ol>
+    <li>First Item</li>
+    <li>Second Item</li>
+    <li>Third Item</li>
+</ol>
+```
+
+### Fragments
+
+You can also "group" elements by wrapping them in `Fragment {}`. This will not create any additional elements.
+
+> Note: you can also render multiple elements at the top level of `rsx!` and they will be automatically grouped – no need for an explicit `Fragment {}` there.
+
+```rust
+{{#include ../../examples/rsx_overview.rs:fragments}}
+```
+
+```html
+<p>First Item</p>
+<p>Second Item</p>
+<span>a group</span>
+<span>of three</span>
+<span>items</span>
+```
+
+### Attributes
+
+Attributes are also specified inside the `{}` brackets, using the `name: value` syntax. You can provide the value as a literal in the RSX:
+```rust
+{{#include ../../examples/rsx_overview.rs:attributes}}
+```
+```html
+<a href="https://www.youtube.com/watch?v=dQw4w9WgXcQ" class="primary_button" autofocus="true">Log In</a>
+```
+
+> Note: All attributes defined in `dioxus-html` follow the snake_case naming convention. They transform their `snake_case` names to HTML's `camelCase` attributes.
+
+#### Custom Attributes
+
+Dioxus has a pre-configured set of attributes that you can use. RSX is validated at compile time to make sure you didn't specify an invalid attribute. If you want to override this behavior with a custom attribute name, specify the attribute in quotes:
+
+```rust
+{{#include ../../examples/rsx_overview.rs:custom_attributes}}
+```
+```html
+<b customAttribute="value">
+    Rust is cool
+</b>
+```
+
+### Interpolation
+
+Similarly to how you can [format](https://doc.rust-lang.org/rust-by-example/hello/print/fmt.html) Rust strings, you can also interpolate in RSX text. Use `{variable}` to Display the value of a variable in a string, or `{variable:?}` to use the Debug representation:
+
+```rust
+{{#include ../../examples/rsx_overview.rs:formatting}}
+```
+```html
+
+<div class="country-es">Coordinates: (42, 0)
+    <div>ES</div>
+    <div>42</div>
+</div>
+```
+
+### Expressions
+
+You can include arbitrary Rust expressions within RSX, but you must escape them in `[]` brackets:
+
+```rust
+{{#include ../../examples/rsx_overview.rs:expression}}
+```
+```html
+<span>DIOXUS</span>
+```

docs/guide/src/en/describing_ui/special_attributes.md

@@ -0,0 +1,63 @@
+# Special Attributes
+
+While most attributes are simply passed on to the HTML, some have special behaviors.
+
+## The HTML Escape Hatch
+
+If you're working with pre-rendered assets, output from templates, or output from a JS library, then you might want to pass HTML directly instead of going through Dioxus. In these instances, reach for `dangerous_inner_html`.
+
+For example, shipping a markdown-to-Dioxus converter might significantly bloat your final application size. Instead, you'll want to pre-render your markdown to HTML and then include the HTML directly in your output. We use this approach for the [Dioxus homepage](https://dioxuslabs.com):
+
+
+```rust
+{{#include ../../examples/dangerous_inner_html.rs:dangerous_inner_html}}
+```
+
+> Note! This attribute is called "dangerous_inner_html" because it is **dangerous** to pass it data you don't trust. If you're not careful, you can easily expose [cross-site scripting (XSS)](https://en.wikipedia.org/wiki/Cross-site_scripting) attacks to your users.
+>
+> If you're handling untrusted input, make sure to sanitize your HTML before passing it into `dangerous_inner_html` – or just pass it to a Text Element to escape any HTML tags.
+
+
+## Boolean Attributes
+
+Most attributes, when rendered, will be rendered exactly as the input you provided. However, some attributes are considered "boolean" attributes and just their presence determines whether they affect the output. For these attributes, a provided value of `"false"` will cause them to be removed from the target element.
+
+So this RSX wouldn't actually render the `hidden` attribute:
+
+```rust
+{{#include ../../examples/boolean_attribute.rs:boolean_attribute}}
+```
+```html
+<div>hello</div>
+```
+
+Not all attributes work like this however. *Only the following attributes* have this behavior:
+
+- `allowfullscreen`
+- `allowpaymentrequest`
+- `async`
+- `autofocus`
+- `autoplay`
+- `checked`
+- `controls`
+- `default`
+- `defer`
+- `disabled`
+- `formnovalidate`
+- `hidden`
+- `ismap`
+- `itemscope`
+- `loop`
+- `multiple`
+- `muted`
+- `nomodule`
+- `novalidate`
+- `open`
+- `playsinline`
+- `readonly`
+- `required`
+- `reversed`
+- `selected`
+- `truespeed`
+
+For any other attributes, a value of `"false"` will be sent directly to the DOM.