@manyducks.co/dolla 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/modules/router.d.ts

@@ -1,6 +1,7 @@
-import { type Stringable } from "../types.js";
-import { ViewNode, type ViewFunction } from "../view.js";
-import type { Dolla } from "./dolla.js";
+import type { Dolla } from "../core/dolla.js";
+import { type ViewFunction } from "../core/nodes/view.js";
+import { IS_ROUTER } from "../core/symbols.js";
+import type { Stringable } from "../types.js";
 export interface RouteMatchContext {
     /**
      * Redirects the user to a different route instead of matching the current one.
@@ -29,14 +30,15 @@ export interface Route {
      */
     beforeMatch?: (ctx: RouteMatchContext) => void | Promise<void>;
 }
+export interface RouteMeta {
+    redirect?: string | ((ctx: RouteRedirectContext) => string) | ((ctx: RouteRedirectContext) => Promise<string>);
+    pattern?: string;
+    layers?: RouteLayer[];
+    beforeMatch?: (ctx: RouteMatchContext) => void | Promise<void>;
+}
 export interface RouteConfig {
     pattern: string;
-    meta: {
-        redirect?: string | ((ctx: RouteRedirectContext) => string) | ((ctx: RouteRedirectContext) => Promise<string>);
-        pattern?: string;
-        layers?: RouteLayer[];
-        beforeMatch?: (ctx: RouteMatchContext) => void | Promise<void>;
-    };
+    meta: RouteMeta;
 }
 export interface RouteLayer {
     id: number;
@@ -63,11 +65,6 @@ export interface RouteRedirectContext {
      */
     query: Record<string, string | number | boolean | undefined>;
 }
-interface ParsedParams {
-    [key: string]: string | number | boolean | (string | number | boolean | null)[] | null;
-}
-interface ParsedQuery extends ParsedParams {
-}
 export interface NavigateOptions {
     /**
      * Replace the current item in the history stack instead of adding a new one.
@@ -79,57 +76,41 @@ export interface NavigateOptions {
      */
     preserveQuery?: boolean;
 }
-export declare enum RoutingStyle {
-    /**
-     * Constructs routes like "https://www.example.com/#/sub/route" which work without any server-side setup.
-     * A good choice if your app has no backend.
-     */
-    hash = "hash",
-    /**
-     * Constructs routes like "https://www.example.com/sub/route" which look nicer (subjective?) than hash routes and are what most users will expect URLs to look like, but require additional backend setup.
-     * Path routing requires you to configure your backend to redirect to the app's index.html when subpaths are requested.
-     */
-    path = "path"
-}
-export interface RouterSetupOptions {
+export interface RouterOptions {
     routes: Route[];
     /**
-     * The routing style to use; "hash" will construct routes like "https://www.example.com/#/sub/route" which work without any server-side setup, while "path" will construct routes that use paths directly.
+     * When true, the router will construct routes like "https://www.example.com/#/sub/route" which work without any backend intervention.
      */
-    style?: RoutingStyle;
-}
-export interface RouterElements {
-    readonly rootElement?: HTMLElement;
-    readonly rootView?: ViewNode;
+    hash?: boolean;
 }
+export declare function createRouter(options: RouterOptions): Router;
+declare const ROUTER_MOUNT: unique symbol;
+declare const ROUTER_UNMOUNT: unique symbol;
+export declare function _isRouter(value: any): value is Router;
+export declare function _mountRouter(router: Router, dolla: Dolla): Promise<void>;
+export declare function _unmountRouter(router: Router): Promise<void>;
 export declare class Router {
     #private;
+    [IS_ROUTER]: boolean;
     /**
      * The currently matched route pattern, if any.
      */
-    $pattern: import("../signals.js").Signal<string | null>;
+    $pattern: import("../core/state.js").State<string | undefined>;
     /**
      * The current URL path.
      */
-    $path: import("../signals.js").Signal<string>;
+    $path: import("../core/state.js").State<string>;
     /**
      * The current named path params.
      */
-    $params: import("../signals.js").Signal<ParsedParams>;
+    $params: import("../core/state.js").State<Record<string, string | number>>;
     /**
      * The current query params. Changes to this object will be reflected in the URL.
      */
-    $query: import("../signals.js").Signal<ParsedQuery>;
-    constructor(dolla: Dolla, elements: RouterElements);
-    setup(options: RouterSetupOptions): void;
-    /**
-     * Navigates to another route.
-     *
-     * @example
-     * navigate("/login"); // navigate to `/login`
-     * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
-     */
-    go(path: Stringable | Stringable[], options?: NavigateOptions): void;
+    $query: import("../core/state.js").State<Record<string, string | number | boolean>>;
+    constructor(options: RouterOptions);
+    [ROUTER_MOUNT](dolla: Dolla): Promise<void>;
+    [ROUTER_UNMOUNT](): Promise<void>;
     /**
      * Navigate backward. Pass a number of steps to hit the back button that many times.
      */
@@ -138,6 +119,14 @@ export declare class Router {
      * Navigate forward. Pass a number of steps to hit the forward button that many times.
      */
     forward(steps?: number): void;
+    /**
+     * Navigates to another route.
+     *
+     * @example
+     * Dolla.router.go("/login"); // navigate to `/login`
+     * Dolla.router.go["/users", 215], { replace: true }); // replace current history entry with `/users/215`
+     */
+    go(path: Stringable | Stringable[], options?: NavigateOptions): void;
 }
 /**
  * Intercepts links within the root node.
@@ -148,5 +137,5 @@ export declare class Router {
  * @param callback - Function to call when a click event is intercepted
  * @param _window - (optional) Override for global window object
  */
-export declare function catchLinks(root: HTMLElement, callback: (anchor: HTMLAnchorElement) => void, _window?: Window & typeof globalThis): () => void;
+export declare function catchLinks(root: Element, callback: (anchor: HTMLAnchorElement) => void, _window?: Window & typeof globalThis): () => void;
 export {};

package/dist/typeChecking.d.ts

@@ -1,8 +1,8 @@
-type TypeNames = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "null" | "array" | "class" | "promise" | "NaN";
+type TypeNames = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "null" | "array" | "class" | "promise" | "map" | "set" | "NaN";
 /**
  * Extends `typeof` operator with more specific and useful type distinctions.
  */
-export declare function typeOf(value: unknown): TypeNames;
+export declare function typeOf(value: any): TypeNames;
 /**
  * Throws a TypeError unless `condition` is truthy.
  *

package/dist/types.d.ts

@@ -1,17 +1,17 @@
 import type * as CSS from "csstype";
-import { Ref, type Markup } from "./markup.js";
-import { SettableSignal, Signal } from "./signals.js";
+import type { Markup } from "./core/markup.js";
+import type { State } from "./core/state.js";
 /**
  * Represents everything that can be handled as a DOM node.
  * These are all the items considered valid to pass as children to any element.
  */
-export type Renderable = string | number | Markup | false | null | undefined | Signal<any> | (string | number | Markup | false | null | undefined | Signal<any>)[];
+export type Renderable = string | number | Markup | false | null | undefined | State<any> | (string | number | Markup | false | null | undefined | State<any>)[];
 export type Stringable = {
     toString(): string;
 };
-type MaybeSignal<T> = T | Signal<T> | Signal<T | undefined>;
-type OptionalProperty<T> = T | Signal<T> | Signal<T | undefined>;
-type RequiredProperty<T> = T | Signal<T>;
+type MaybeState<T> = T | State<T> | State<T | undefined>;
+type OptionalProperty<T> = T | State<T> | State<T | undefined>;
+type RequiredProperty<T> = T | State<T>;
 type AutocapitalizeValues = "off" | "on" | "none" | "sentences" | "words" | "characters";
 type ContentEditableValues = true | false | "true" | "false" | "plaintext-only" | "inherit";
 type ClassListValues = string | ClassMap | Array<string | ClassMap | (string | ClassMap)[]>;
@@ -110,7 +110,7 @@ export interface ElementProps {
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
      */
-    style?: string | CSSProperties | Signal<string> | Signal<CSSProperties> | Signal<string | CSSProperties> | Signal<string | undefined> | Signal<CSSProperties | undefined> | Signal<string | CSSProperties | undefined>;
+    style?: string | CSSProperties | State<string> | State<CSSProperties> | State<string | CSSProperties> | State<string | undefined> | State<CSSProperties | undefined> | State<string | CSSProperties | undefined>;
     /**
      * Fired when a CSS animation unexpectedly aborts.
      *
@@ -1210,7 +1210,7 @@ export type CSSProperties = {
     [K in keyof Styles]: OptionalProperty<Styles[K]>;
 };
 export interface ClassMap {
-    [className: string]: MaybeSignal<any>;
+    [className: string]: MaybeState<any>;
 }
 export type EventHandler<E> = (event: E) => void;
 export interface PropertiesOf<E extends HTMLElement> extends HTMLElementProps {
@@ -1219,9 +1219,9 @@ export interface PropertiesOf<E extends HTMLElement> extends HTMLElementProps {
      */
     children?: any;
     /**
-     * A settable signal or callback that receives the DOM node when rendered.
+     * Receives a reference to the DOM node when rendered.
      */
-    ref?: Ref<E> | Ref<HTMLElement> | Ref<Element> | Ref<Node>;
+    ref?: ((value: E | undefined) => void) | ((value: HTMLElement | undefined) => void) | ((value: Element | undefined) => void) | ((value: Node | undefined) => void);
 }
 /**
  * The following elements are defined based on the WHATWG HTML spec:
@@ -2098,7 +2098,7 @@ interface HTMLMediaElementProps<T extends HTMLMediaElement> extends HTMLElementP
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/srcObject
      */
-    srcObject?: MediaStream | MediaSource | Blob | File | Signal<MediaStream> | Signal<MediaStream | undefined> | Signal<MediaSource> | Signal<MediaSource | undefined> | Signal<Blob> | Signal<Blob | undefined> | Signal<File> | Signal<File | undefined>;
+    srcObject?: MediaStream | MediaSource | Blob | File | State<MediaStream> | State<MediaStream | undefined> | State<MediaSource> | State<MediaSource | undefined> | State<Blob> | State<Blob | undefined> | State<File> | State<File | undefined>;
     /**
      * The current audio volume of the media element. Must be a number between 0 and 1.
      *
@@ -2597,7 +2597,7 @@ interface HTMLImageElementProps extends PropertiesOf<HTMLImageElement> {
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/sizes
      */
-    sizes?: MaybeSignal<string>;
+    sizes?: MaybeState<string>;
     /**
      * The image URL.
      *
@@ -3143,7 +3143,6 @@ interface HTMLInputElementProps extends PropertiesOf<HTMLInputElement> {
     step?: OptionalProperty<number>;
     type?: OptionalProperty<InputType>;
     value?: OptionalProperty<string>;
-    $$value?: SettableSignal<any>;
     width?: OptionalProperty<string | number> | OptionalProperty<string> | OptionalProperty<number>;
     title?: OptionalProperty<string>;
     /**

package/dist/utils.d.ts

@@ -1,5 +1,18 @@
 export declare const noOp: () => void;
-export declare function deepEqual(one: any, two: any): boolean;
+export declare function getUniqueId(): string;
+/**
+ * Equality check that passes if both values are the same object.
+ * This is the default equality check for states.
+ */
+export declare function strictEqual(a: any, b: any): boolean;
+/**
+ * Equality check that passes if both values are the same object, or if both are objects or arrays with equal keys and values.
+ */
+export declare function shallowEqual(a: any, b: any): boolean;
+/**
+ * Equality check that passes if two objects have equal values, even if they are not the same object.
+ */
+export declare const deepEqual: (a: any, b: any) => boolean;
 /**
  * Takes an old value and a new value.  Returns a merged copy if both are objects, otherwise returns the new value.
  */
@@ -13,7 +26,6 @@ export declare function merge(one: unknown, two: unknown): any;
  * @param object - An object to clone without the omitted keys.
  */
 export declare function omit<O extends Record<any, any>>(keys: (keyof O)[], object: O): Record<any, any>;
-export declare function getDefaultConsole(): any;
 export declare function colorFromString(value: string): string;
 export type MatcherFunction = (value: string) => boolean;
 /**

package/dist/views/default-crash-view.d.ts

@@ -15,4 +15,4 @@ export type CrashViewProps = {
      */
     uid?: string;
 };
-export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup | import("../markup.js").Markup[];
+export declare function DefaultCrashView(props: CrashViewProps): import("../core/markup.js").Markup | import("../core/markup.js").Markup[];

package/dist/views/passthrough.d.ts

@@ -1,5 +1,5 @@
-import { type ViewContext } from "../view.js";
+import { type ViewContext } from "../core/nodes/view.js";
 /**
  * A utility view that simply displays its children.
  */
-export declare function Passthrough(_: {}, ctx: ViewContext): import("../markup.js").Markup;
+export declare function Passthrough(_: {}, ctx: ViewContext): import("../index.js").Markup;

package/docs/http.md

@@ -0,0 +1,29 @@
+# HTTP Client
+
+> TODO: Write me.
+
+This page goes into detail on how to use the built in HTTP client.
+
+```js
+import Dolla from "@manyducks.co/dolla";
+
+Dolla.http.use(async (req, next) => {
+  // Apply auth header to all API routes.
+  if (req.url.pathname.startsWith("/api/")) {
+    req.headers.set("authorization", `Bearer ${localStorage.getItem("api-key")}`);
+  }
+
+  await next();
+});
+
+const res = await Dolla.http.get("/api/some-api-route");
+res.body; // body is already parsed as JSON if server responded with JSON
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/i18n.md

@@ -0,0 +1,38 @@
+# Internationalization (i18n) Support
+
+```jsx
+import Dolla, { createView, createState, t } from "@manyducks.co/dolla";
+
+const CounterView = createView(function (props) {
+  const [$count, setCount] = createState(0);
+
+  const increment = () => {
+    setCount((count) => count + 1);
+  };
+
+  return (
+    <div>
+      <p>Clicks: {$count}</p>
+      <button onClick={increment}>{t("buttonLabel")}</button>
+    </div>
+  );
+});
+
+Dolla.i18n.setup({
+  locale: "en",
+  translations: [
+    { locale: "en", strings: { buttonLabel: "Click here to increment" } },
+    { locale: "ja", strings: { buttonLabel: "ここに押して増加する" } },
+  ],
+});
+
+Dolla.mount(document.body, CounterView);
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/index.md

@@ -0,0 +1,10 @@
+# Dolla Docs
+
+> Write table of contents (see files in this folder in the meantime)
+
+---
+
+End.
+
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/router.md

@@ -0,0 +1,77 @@
+# Router
+
+Dolla makes heavy use of client-side routing. You can define as many routes as you have views, and the URL
+will determine which one the app shows at any given time. By building an app around routes, lots of things one expects
+from a web app will just work; back and forward buttons, sharable URLs, bookmarks, etc.
+
+Routes are matched by highest specificity regardless of the order they were registered.
+This avoids some confusing situations that come up with order-based routers like that of `express`.
+On the other hand, order-based routers can support regular expressions as patterns which Dolla's router cannot.
+
+## Route Patterns
+
+Routes are defined with strings called patterns. A pattern defines the shape the URL path must match, with special
+placeholders for variables that appear within the route. Values matched by those placeholders are parsed out and exposed
+to your code (`router` store, `$params` readable). Below are some examples of patterns and how they work.
+
+- Static: `/this/is/static` has no params and will match only when the route is exactly `/this/is/static`.
+- Numeric params: `/users/{#id}/edit` has the named param `{#id}` which matches numbers only, such as `123` or `52`. The
+  resulting value will be parsed as a number.
+- Generic params: `/users/{name}` has the named param `{name}` which matches anything in that position in the path. The
+  resulting value will be a string.
+- Wildcard: `/users/*` will match anything beginning with `/users` and store everything after that in params
+  as `wildcard`. `*` is valid only at the end of a route.
+
+Now, here are some route examples in the context of an app:
+
+```js
+import Dolla from "@manyducks.co/dolla";
+import { ThingIndex, ThingDetails, ThingEdit, ThingDelete } from "./views.js";
+
+Dolla.router.setup({
+  routes: [
+    {
+      // A `null` component with subroutes acts as a namespace for those subroutes.
+      // Passing a view instead of `null` results in subroutes being rendered inside that view wherever `ctx.outlet()` is called.
+      path: "/things",
+      view: null,
+      routes: [
+        { path: "/", view: ThingIndex }, // matches `/things`
+        { path: "/{#id}", view: ThingDetails }, // matches `/things/{#id}`
+        { path: "/{#id}/edit", view: ThingEdit }, // matches `/things/{#id}/edit`
+        { path: "/{#id}/delete", view: ThingDelete }, // matches `/things/{#id}/delete`
+      ],
+    },
+    // All routes that don't match anything else will redirect to `/things`
+    { path: "*", redirect: "/things" },
+  ],
+});
+```
+
+When the URL matches a pattern the corresponding view is displayed. If we visit `/people/john`,
+we will see the `PersonDetails` view and the params will be `{ name: "john" }`. Params can be
+accessed from anywhere in the app through `Dolla.router`.
+
+```js
+import Dolla from "@manyducks.co/dolla";
+
+// Info about the current route is exported as a set of Readables. Query params are also Writable through $$query:
+const { $path, $pattern, $params, $query } = Dolla.router;
+
+Dolla.router.back(); // Step back in the history to the previous route, if any.
+Dolla.router.back(2); // Hit the back button twice.
+
+Dolla.router.forward(); // Step forward in the history to the next route, if any.
+Dolla.router.forward(4); // Hit the forward button 4 times.
+
+Dolla.router.go("/things/152"); // Navigate to another path within the same app.
+Dolla.router.go("https://www.example.com/another/site"); // Navigate to another domain entirely.
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/setup.md

@@ -0,0 +1,31 @@
+# Setting up Dolla
+
+## Installation
+
+Dolla is published on npm as `@manyducks.co/dolla`. You can install it in your project with the following command:
+
+```
+npm i @manyducks.co/dolla
+```
+
+## JSX
+
+If you want to use JSX in your app you can add the following options to your `tsconfig.json` or `jsconfig.json`. Modern build systems like [Vite](https://vite.dev) will pick these up automatically.
+
+```json
+{
+  "compilerOptions": {
+    // ... other options ...
+    "jsx": "react-jsx",
+    "jsxImportSource": "@manyducks.co/dolla"
+  }
+}
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/state.md

@@ -0,0 +1,141 @@
+## ⚡ Reactive Updates with `State`
+
+Dolla sets out to solve the challenge of keeping your UI in sync with your data. All apps have state that changes at runtime, and as those values change your UI must update itself to stay in sync with that state. JavaScript frameworks all have their own ways of meeting this challenge, but there are two main ones; virtual DOM and signals.
+
+[React](https://react.dev) and similar frameworks make use of a [virtual DOM](https://svelte.dev/blog/virtual-dom-is-pure-overhead), in which every state change causes a "diff" of the real DOM nodes on the page against a lightweight representation of what those nodes _should_ look like, followed by a "patch" where the minimal updates are performed to bring the DOM in line with the ideal virtual DOM.
+
+[Solid](https://www.solidjs.com) and similar frameworks make use of [signals](https://dev.to/this-is-learning/the-evolution-of-signals-in-javascript-8ob), which are containers for data that will change over time. Signal values are accessed through special getter functions that can be called inside of a "scope" to track their values. When the value of a tracked signal changes, any computations that happened in scopes that depend on those signals are re-run. In an app like this, all of your DOM updates are performed with pinpoint accuracy without diffing as signal values change.
+
+Dolla uses a concept of a `State`, which is a signal-like container for values that change over time. Where `State` differs from signals, however, is that there is no magical scope tracking going on behind the scenes. All States that depend on others do so explicity, so your code is easier to read and understand.
+
+The `State` API has just four functions:
+
+- `createState` to create a new state and a linked setter function.
+- `derive` to create a new state whose value depends on one or more other states.
+- `toState` to ensure that a value is a state object.
+- `toValue` to ensure that a value is a plain value.
+
+### Basic State API
+
+```js
+import { createState } from "@manyducks.co/dolla";
+
+// Equivalent to React's `useState` or Solid's `createSignal`.
+// A new read-only State and linked Setter are created.
+const [$count, setCount] = createState(72);
+
+// Get the current value.
+$count.get(): // 72
+
+// Set a new value.
+setCount(300);
+
+// The State now reflects the latest value.
+$count.get(); // 300
+
+// Data can also be updated by passing a function.
+// This function takes the current state and returns a new one.
+setCount((current) => current + 1);
+$count.get(); // 301
+```
+
+### Deriving States from other States
+
+#### Example 1: Doubled
+
+```js
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$count, setCount] = createState(1);
+
+const $doubled = derive([$count], (count) => count * 2);
+
+setCount(10);
+$doubled.get(); // 20
+```
+
+That was a typical toy example where we create a `$doubled` state that always contains the value of `$count`... doubled! This is the essential basic example of computed properties, as written in Dolla.
+
+#### Example 2: Selecting a User
+
+```js
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$users, setUsers] = createState([
+  { id: 1, name: "Audie" },
+  { id: 2, name: "Bob" },
+  { id: 3, name: "Cabel" },
+]);
+const [$selectedUserId, setSelectedUserId] = createState(1);
+
+const $selectedUser = derive([$users, $selectedUserId], (users, id) => {
+  return users.find((user) => user.id === id);
+});
+
+$selectedUser.get(); // { id: 1, name: "Audie" }
+
+setSelectedId(3);
+
+$selectedUser.get(); // { id: 3, name: "Cabel" }
+```
+
+That was a more realistic example you might actually use in real life. Here we are selecting a user from a list based on its `id` field. This is kind of similar to a `JOIN` operation in a SQL database. I use this kind of pattern constantly in my apps.
+
+The strength of setting up a join like this is that the `$users` array can be updated (by API call, websockets, etc.) and your `$selectedUser` will always be pointing to the latest version of the user data.
+
+#### Example 3: Narrowing Complex Data
+
+```jsx
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$user, setUser] = createState({ id: 1, name: "Audie" });
+
+const $name = derive([$user], (user) => user.name);
+
+$name.get(); // "Audie"
+
+// In a view:
+<span class="user-name">{$name}</span>;
+```
+
+Another common pattern. In a real app, most data is stored as arrays of objects. But what you need in order to slot it into a view is just a string. In the example above we've selected the user's name and slotted it into a `span`. If the `$user` value ever changes, the name will stay in sync.
+
+### Converting to and from States
+
+```js
+import { createState, toState, toValue } from "@manyducks.co/dolla";
+
+const [$count, setCount] = createState(512);
+
+// Unwrap the value of $count. Returns 512.
+const count = toValue($count);
+// Passing a non-state value will simply return it.
+const name = toValue("World");
+
+// Wrap "Hello" into a State containing "Hello"
+const $value = toState("Hello");
+// Passing a state will simply return that same state.
+const $number = toState($count);
+```
+
+### In Views
+
+```jsx
+import { derive, createView } from "@manyducks.co/dolla";
+
+const UserNameView = createView(function (props) {
+  const $name = derive([props.$user], (user) => user.name);
+
+  return <span class={{ "user-name": true, "is-selected": props.$selected }}>{$name}</span>;
+});
+```
+
+In the example above we've displayed the `name` field from a `$user` object inside of a span. We are also assigning an `is-selected` class dynamically based on whether the `$selected` prop contains a truthy or falsy value.
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)