Index

Documents: module examples/exceptions, module examples/overview.

Modules: tree, tree/domextras, tree/js, tree/jsset, tree/signal, tree/store.

API symbols

`()`:

• store: proc `()`[T](s: Store[T]): T

a:

• js: template a(): AElement

Accessor:

• signal: type Accessor

addContext:

• signal: proc addContext(ctx: Context)

AElement:

• domextras: type AElement

BaseElement:

• domextras: type BaseElement

button:

• js: template button(): ButtonElement

ButtonElement:

• domextras: type ButtonElement

checkExpr:

• js: template checkExpr(val: typed): untyped

clear:

• jsset: proc clear(s: JSSet)

coerceIntoElement:

• js: template coerceIntoElement(val: string | Accessor[string]): untyped

contains:

• jsset: proc contains[T](s: JSSet[T]): bool

Context:

• signal: type Context

createEffect:

• signal: proc createEffect(callback: proc ())

createMemo:

• signal: proc createMemo[T](callback: Accessor[T]): Accessor[T]

createSignal:

• signal: proc createSignal[T](init: T): Signal[T]

createStore:

• store: proc createStore[T](init: T = default(T)): Store[T]

entries:

• jsset: proc entries[T](s: JSSet[T]): Iterator[array[2, T]]

fieldset:

• js: template fieldset(): BaseElement

form:

• js: template form(): FormElement

getContext:

• signal: proc getContext[T: Context](kind: typedesc[T]): T

gui:

• js: macro gui(body: untyped): Element

h1:

• js: template h1(): BaseElement

h2:

• js: template h2(): BaseElement

h3:

• js: template h3(): BaseElement

h4:

• js: template h4(): BaseElement

h5:

• js: template h5(): BaseElement

hash:

• signal: proc hash(x: Observer): Hash

img:

• js: template img(): ImgElement

ImgElement:

• domextras: type ImgElement

inc:

• signal: proc inc[T: SomeInteger](signal: Signal[T]; amount: T = 1)

incl:

• jsset: proc incl[T](s: JSSet[T]; val: T)

initRoot:

• signal: proc initRoot[T](body: Accessor[T]): T

input:

• js: template input(): InputElement

insert:

• js: proc insert[T: Element | seq[Element]](box: Element; value: Accessor[T]; current: T = default(T); prev: Accessor[Element] = nil): Accessor[ Element]
• js: proc insert(box, value: Element; prev: Accessor[Element]): Element
• js: proc insert(box, value, current: Element): Element
• js: proc insert(box: Element; value, current: seq[Element]; marker: Element): seq[Element]

items:

• jsset: iterator items[T](s: JSSet[T]): T

jsHandler:

• js: macro jsHandler(handler: typedesc[proc]): typedesc

JSSet:

• jsset: type JSSet

kind=:

• domextras: proc kind=(e: InputElement; kind: cstring)

label:

• js: template label(): LabelElement

LabelElement:

• domextras: type LabelElement

legend:

• js: template legend(): BaseElement

li:

• js: template li(): ButtonElement

listener:

• signal: var listener

name:

• domextras: proc name(event: Event): cstring

nav:

• js: template nav(): ButtonElement

newJSSet:

• jsset: proc newJSSet[T](): JSSet[T]

ol:

• js: template ol(): ButtonElement

onCleanup:

• signal: proc onCleanup(x: Callback)

option:

• js: template option(): OptionElement

owner:

• signal: var owner

p:

• js: template p(): BaseElement

performsRead:

• signal: macro performsRead(x: proc): bool

prepend:

• domextras: proc prepend(e: Element; children: Node)

rawGet:

• store: proc rawGet[T](s: Store[T]): lent T

ReadEffect:

• signal: object ReadEffect

registerElement:

• js: macro registerElement(name: static[string]; kind: typedesc; elemName: static[string] = ""): untyped

registerEvent:

• js: proc registerEvent(elem: EventTarget; name: cstring; callback: (proc ()))
• js: proc registerEvent[E: Event](elem: EventTarget; name: cstring; callback: (proc (ev: E)))

remove:

• js: proc remove(child: Node)

renderTo:

• js: proc renderTo(component: proc (): Element; id: string)

select:

• js: template select(): BaseElement
• store: proc select[T, R](s: Store[T]; selector: proc (x: T): R): Accessor[R]

Setter:

• signal: type Setter

Signal:

• signal: tuple Signal

span:

• js: template span(): BaseElement

Store:

• store: type Store

strong:

• js: template strong(): BaseElement

tdiv:

• js: template tdiv(): BaseElement

text:

• js: proc text(val: Accessor[string]): Accessor[Node]
• js: proc text(val: cstring): Node
• js: proc text(val: string): Node

ul:

• js: template ul(): ButtonElement

untrack:

• signal: template untrack[T: not void](body: T): T
• signal: template untrack(body: untyped): untyped

update:

• store: proc update[T](s: Store[T]; updater: proc (x: var T))
• store: proc update[T](s: Store[T]; newVal: T)