fulcro.client.dom — fulcrologic/fulcro 2.5.12

clj

MACROS for generating CLJS code. See dom.cljs

cljs

Client-side DOM macros and functions. For isomorphic (server) support, see also fulcro.client.dom-server

a clj/s macro

(a & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (a "hello") (a nil "hello")

These two are made equivalent at compile time (a {:onClick f} "hello") (a #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (a :#the-id.klass.other-klass "hello") (a :#the-id.klass.other-klass {:onClick f} "hello")

abbr clj/s macro

(abbr & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (abbr "hello") (abbr nil "hello")

These two are made equivalent at compile time (abbr {:onClick f} "hello") (abbr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (abbr :#the-id.klass.other-klass "hello") (abbr :#the-id.klass.other-klass {:onClick f} "hello")

address clj/s macro

(address & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (address "hello") (address nil "hello")

These two are made equivalent at compile time (address {:onClick f} "hello") (address #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (address :#the-id.klass.other-klass "hello") (address :#the-id.klass.other-klass {:onClick f} "hello")

area clj/s macro

(area & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (area "hello") (area nil "hello")

These two are made equivalent at compile time (area {:onClick f} "hello") (area #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (area :#the-id.klass.other-klass "hello") (area :#the-id.klass.other-klass {:onClick f} "hello")

article clj/s macro

(article & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (article "hello") (article nil "hello")

These two are made equivalent at compile time (article {:onClick f} "hello") (article #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (article :#the-id.klass.other-klass "hello") (article :#the-id.klass.other-klass {:onClick f} "hello")

aside clj/s macro

(aside & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (aside "hello") (aside nil "hello")

These two are made equivalent at compile time (aside {:onClick f} "hello") (aside #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (aside :#the-id.klass.other-klass "hello") (aside :#the-id.klass.other-klass {:onClick f} "hello")

audio clj/s macro

(audio & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (audio "hello") (audio nil "hello")

These two are made equivalent at compile time (audio {:onClick f} "hello") (audio #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (audio :#the-id.klass.other-klass "hello") (audio :#the-id.klass.other-klass {:onClick f} "hello")

b clj/s macro

(b & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (b "hello") (b nil "hello")

These two are made equivalent at compile time (b {:onClick f} "hello") (b #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (b :#the-id.klass.other-klass "hello") (b :#the-id.klass.other-klass {:onClick f} "hello")

base clj/s macro

(base & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (base "hello") (base nil "hello")

These two are made equivalent at compile time (base {:onClick f} "hello") (base #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (base :#the-id.klass.other-klass "hello") (base :#the-id.klass.other-klass {:onClick f} "hello")

bdi clj/s macro

(bdi & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (bdi "hello") (bdi nil "hello")

These two are made equivalent at compile time (bdi {:onClick f} "hello") (bdi #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (bdi :#the-id.klass.other-klass "hello") (bdi :#the-id.klass.other-klass {:onClick f} "hello")

bdo clj/s macro

(bdo & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (bdo "hello") (bdo nil "hello")

These two are made equivalent at compile time (bdo {:onClick f} "hello") (bdo #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (bdo :#the-id.klass.other-klass "hello") (bdo :#the-id.klass.other-klass {:onClick f} "hello")

big clj/s macro

(big & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (big "hello") (big nil "hello")

These two are made equivalent at compile time (big {:onClick f} "hello") (big #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (big :#the-id.klass.other-klass "hello") (big :#the-id.klass.other-klass {:onClick f} "hello")

blockquote clj/s macro

(blockquote & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (blockquote "hello") (blockquote nil "hello")

These two are made equivalent at compile time (blockquote {:onClick f} "hello") (blockquote #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (blockquote :#the-id.klass.other-klass "hello") (blockquote :#the-id.klass.other-klass {:onClick f} "hello")

body clj/s macro

(body & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (body "hello") (body nil "hello")

These two are made equivalent at compile time (body {:onClick f} "hello") (body #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (body :#the-id.klass.other-klass "hello") (body :#the-id.klass.other-klass {:onClick f} "hello")

br clj/s macro

(br & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (br "hello") (br nil "hello")

These two are made equivalent at compile time (br {:onClick f} "hello") (br #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (br :#the-id.klass.other-klass "hello") (br :#the-id.klass.other-klass {:onClick f} "hello")

button clj/s macro

(button & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (button "hello") (button nil "hello")

These two are made equivalent at compile time (button {:onClick f} "hello") (button #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (button :#the-id.klass.other-klass "hello") (button :#the-id.klass.other-klass {:onClick f} "hello")

canvas clj/s macro

(canvas & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (canvas "hello") (canvas nil "hello")

These two are made equivalent at compile time (canvas {:onClick f} "hello") (canvas #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (canvas :#the-id.klass.other-klass "hello") (canvas :#the-id.klass.other-klass {:onClick f} "hello")

caption clj/s macro

(caption & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (caption "hello") (caption nil "hello")

These two are made equivalent at compile time (caption {:onClick f} "hello") (caption #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (caption :#the-id.klass.other-klass "hello") (caption :#the-id.klass.other-klass {:onClick f} "hello")

circle clj/s macro

(circle & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (circle "hello") (circle nil "hello")

These two are made equivalent at compile time (circle {:onClick f} "hello") (circle #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (circle :#the-id.klass.other-klass "hello") (circle :#the-id.klass.other-klass {:onClick f} "hello")

cite clj/s macro

(cite & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (cite "hello") (cite nil "hello")

These two are made equivalent at compile time (cite {:onClick f} "hello") (cite #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (cite :#the-id.klass.other-klass "hello") (cite :#the-id.klass.other-klass {:onClick f} "hello")

clipPath clj/s macro

(clipPath & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (clipPath "hello") (clipPath nil "hello")

These two are made equivalent at compile time (clipPath {:onClick f} "hello") (clipPath #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (clipPath :#the-id.klass.other-klass "hello") (clipPath :#the-id.klass.other-klass {:onClick f} "hello")

clj-map->js-object clj

(clj-map->js-object m)

Recursively convert a map to a JS object. For use in macro expansion.

code clj/s macro

(code & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (code "hello") (code nil "hello")

These two are made equivalent at compile time (code {:onClick f} "hello") (code #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (code :#the-id.klass.other-klass "hello") (code :#the-id.klass.other-klass {:onClick f} "hello")

col clj/s macro

(col & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (col "hello") (col nil "hello")

These two are made equivalent at compile time (col {:onClick f} "hello") (col #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (col :#the-id.klass.other-klass "hello") (col :#the-id.klass.other-klass {:onClick f} "hello")

colgroup clj/s macro

(colgroup & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (colgroup "hello") (colgroup nil "hello")

These two are made equivalent at compile time (colgroup {:onClick f} "hello") (colgroup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (colgroup :#the-id.klass.other-klass "hello") (colgroup :#the-id.klass.other-klass {:onClick f} "hello")

convert-props cljs

(convert-props props)

Given props, which can be nil, a js-obj or a clj map: returns a js object.

create-element cljs

(create-element tag)

(create-element tag opts)

(create-element tag opts & children)

Create a DOM element for which there exists no corresponding function. Useful to create DOM elements not included in React.DOM. Equivalent to calling js/React.createElement

data clj/s macro

(data & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (data "hello") (data nil "hello")

These two are made equivalent at compile time (data {:onClick f} "hello") (data #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (data :#the-id.klass.other-klass "hello") (data :#the-id.klass.other-klass {:onClick f} "hello")

datalist clj/s macro

(datalist & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (datalist "hello") (datalist nil "hello")

These two are made equivalent at compile time (datalist {:onClick f} "hello") (datalist #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (datalist :#the-id.klass.other-klass "hello") (datalist :#the-id.klass.other-klass {:onClick f} "hello")

dd clj/s macro

(dd & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dd "hello") (dd nil "hello")

These two are made equivalent at compile time (dd {:onClick f} "hello") (dd #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dd :#the-id.klass.other-klass "hello") (dd :#the-id.klass.other-klass {:onClick f} "hello")

defs clj/s macro

(defs & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (defs "hello") (defs nil "hello")

These two are made equivalent at compile time (defs {:onClick f} "hello") (defs #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (defs :#the-id.klass.other-klass "hello") (defs :#the-id.klass.other-klass {:onClick f} "hello")

del clj/s macro

(del & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (del "hello") (del nil "hello")

These two are made equivalent at compile time (del {:onClick f} "hello") (del #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (del :#the-id.klass.other-klass "hello") (del :#the-id.klass.other-klass {:onClick f} "hello")

details clj/s macro

(details & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (details "hello") (details nil "hello")

These two are made equivalent at compile time (details {:onClick f} "hello") (details #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (details :#the-id.klass.other-klass "hello") (details :#the-id.klass.other-klass {:onClick f} "hello")

dfn clj/s macro

(dfn & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dfn "hello") (dfn nil "hello")

These two are made equivalent at compile time (dfn {:onClick f} "hello") (dfn #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dfn :#the-id.klass.other-klass "hello") (dfn :#the-id.klass.other-klass {:onClick f} "hello")

dialog clj/s macro

(dialog & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dialog "hello") (dialog nil "hello")

These two are made equivalent at compile time (dialog {:onClick f} "hello") (dialog #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dialog :#the-id.klass.other-klass "hello") (dialog :#the-id.klass.other-klass {:onClick f} "hello")

div clj/s macro

(div & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (div "hello") (div nil "hello")

These two are made equivalent at compile time (div {:onClick f} "hello") (div #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (div :#the-id.klass.other-klass "hello") (div :#the-id.klass.other-klass {:onClick f} "hello")

dl clj/s macro

(dl & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dl "hello") (dl nil "hello")

These two are made equivalent at compile time (dl {:onClick f} "hello") (dl #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dl :#the-id.klass.other-klass "hello") (dl :#the-id.klass.other-klass {:onClick f} "hello")

dt clj/s macro

(dt & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dt "hello") (dt nil "hello")

These two are made equivalent at compile time (dt {:onClick f} "hello") (dt #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dt :#the-id.klass.other-klass "hello") (dt :#the-id.klass.other-klass {:onClick f} "hello")

element? cljs

(element? x)

Returns true if the given arg is a react element.

ellipse clj/s macro

(ellipse & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ellipse "hello") (ellipse nil "hello")

These two are made equivalent at compile time (ellipse {:onClick f} "hello") (ellipse #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ellipse :#the-id.klass.other-klass "hello") (ellipse :#the-id.klass.other-klass {:onClick f} "hello")

em clj/s macro

(em & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (em "hello") (em nil "hello")

These two are made equivalent at compile time (em {:onClick f} "hello") (em #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (em :#the-id.klass.other-klass "hello") (em :#the-id.klass.other-klass {:onClick f} "hello")

embed clj/s macro

(embed & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (embed "hello") (embed nil "hello")

These two are made equivalent at compile time (embed {:onClick f} "hello") (embed #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (embed :#the-id.klass.other-klass "hello") (embed :#the-id.klass.other-klass {:onClick f} "hello")

fieldset clj/s macro

(fieldset & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (fieldset "hello") (fieldset nil "hello")

These two are made equivalent at compile time (fieldset {:onClick f} "hello") (fieldset #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (fieldset :#the-id.klass.other-klass "hello") (fieldset :#the-id.klass.other-klass {:onClick f} "hello")

figcaption clj/s macro

(figcaption & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (figcaption "hello") (figcaption nil "hello")

These two are made equivalent at compile time (figcaption {:onClick f} "hello") (figcaption #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (figcaption :#the-id.klass.other-klass "hello") (figcaption :#the-id.klass.other-klass {:onClick f} "hello")

figure clj/s macro

(figure & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (figure "hello") (figure nil "hello")

These two are made equivalent at compile time (figure {:onClick f} "hello") (figure #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (figure :#the-id.klass.other-klass "hello") (figure :#the-id.klass.other-klass {:onClick f} "hello")

footer clj/s macro

(footer & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (footer "hello") (footer nil "hello")

These two are made equivalent at compile time (footer {:onClick f} "hello") (footer #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (footer :#the-id.klass.other-klass "hello") (footer :#the-id.klass.other-klass {:onClick f} "hello")

form clj/s macro

(form & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (form "hello") (form nil "hello")

These two are made equivalent at compile time (form {:onClick f} "hello") (form #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (form :#the-id.klass.other-klass "hello") (form :#the-id.klass.other-klass {:onClick f} "hello")

form-elements? cljs

g clj/s macro

(g & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (g "hello") (g nil "hello")

These two are made equivalent at compile time (g {:onClick f} "hello") (g #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (g :#the-id.klass.other-klass "hello") (g :#the-id.klass.other-klass {:onClick f} "hello")

gen-client-dom-fns clj/s macro

(gen-client-dom-fns create-element-sym)

gen-dom-macro clj

(gen-dom-macro emitter name)

gen-dom-macros clj/s macro

(gen-dom-macros emitter)

h1 clj/s macro

(h1 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h1 "hello") (h1 nil "hello")

These two are made equivalent at compile time (h1 {:onClick f} "hello") (h1 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h1 :#the-id.klass.other-klass "hello") (h1 :#the-id.klass.other-klass {:onClick f} "hello")

h2 clj/s macro

(h2 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h2 "hello") (h2 nil "hello")

These two are made equivalent at compile time (h2 {:onClick f} "hello") (h2 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h2 :#the-id.klass.other-klass "hello") (h2 :#the-id.klass.other-klass {:onClick f} "hello")

h3 clj/s macro

(h3 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h3 "hello") (h3 nil "hello")

These two are made equivalent at compile time (h3 {:onClick f} "hello") (h3 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h3 :#the-id.klass.other-klass "hello") (h3 :#the-id.klass.other-klass {:onClick f} "hello")

h4 clj/s macro

(h4 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h4 "hello") (h4 nil "hello")

These two are made equivalent at compile time (h4 {:onClick f} "hello") (h4 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h4 :#the-id.klass.other-klass "hello") (h4 :#the-id.klass.other-klass {:onClick f} "hello")

h5 clj/s macro

(h5 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h5 "hello") (h5 nil "hello")

These two are made equivalent at compile time (h5 {:onClick f} "hello") (h5 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h5 :#the-id.klass.other-klass "hello") (h5 :#the-id.klass.other-klass {:onClick f} "hello")

h6 clj/s macro

(h6 & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h6 "hello") (h6 nil "hello")

These two are made equivalent at compile time (h6 {:onClick f} "hello") (h6 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h6 :#the-id.klass.other-klass "hello") (h6 :#the-id.klass.other-klass {:onClick f} "hello")

head clj/s macro

(head & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (head "hello") (head nil "hello")

These two are made equivalent at compile time (head {:onClick f} "hello") (head #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (head :#the-id.klass.other-klass "hello") (head :#the-id.klass.other-klass {:onClick f} "hello")

header clj/s macro

(header & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (header "hello") (header nil "hello")

These two are made equivalent at compile time (header {:onClick f} "hello") (header #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (header :#the-id.klass.other-klass "hello") (header :#the-id.klass.other-klass {:onClick f} "hello")

hr clj/s macro

(hr & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (hr "hello") (hr nil "hello")

These two are made equivalent at compile time (hr {:onClick f} "hello") (hr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (hr :#the-id.klass.other-klass "hello") (hr :#the-id.klass.other-klass {:onClick f} "hello")

html clj/s macro

(html & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (html "hello") (html nil "hello")

These two are made equivalent at compile time (html {:onClick f} "hello") (html #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (html :#the-id.klass.other-klass "hello") (html :#the-id.klass.other-klass {:onClick f} "hello")

i clj/s macro

(i & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (i "hello") (i nil "hello")

These two are made equivalent at compile time (i {:onClick f} "hello") (i #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (i :#the-id.klass.other-klass "hello") (i :#the-id.klass.other-klass {:onClick f} "hello")

iframe clj/s macro

(iframe & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (iframe "hello") (iframe nil "hello")

These two are made equivalent at compile time (iframe {:onClick f} "hello") (iframe #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (iframe :#the-id.klass.other-klass "hello") (iframe :#the-id.klass.other-klass {:onClick f} "hello")

img clj/s macro

(img & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (img "hello") (img nil "hello")

These two are made equivalent at compile time (img {:onClick f} "hello") (img #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (img :#the-id.klass.other-klass "hello") (img :#the-id.klass.other-klass {:onClick f} "hello")

input clj/s macro

(input & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (input "hello") (input nil "hello")

These two are made equivalent at compile time (input {:onClick f} "hello") (input #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (input :#the-id.klass.other-klass "hello") (input :#the-id.klass.other-klass {:onClick f} "hello")

ins clj/s macro

(ins & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ins "hello") (ins nil "hello")

These two are made equivalent at compile time (ins {:onClick f} "hello") (ins #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ins :#the-id.klass.other-klass "hello") (ins :#the-id.klass.other-klass {:onClick f} "hello")

kbd clj/s macro

(kbd & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (kbd "hello") (kbd nil "hello")

These two are made equivalent at compile time (kbd {:onClick f} "hello") (kbd #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (kbd :#the-id.klass.other-klass "hello") (kbd :#the-id.klass.other-klass {:onClick f} "hello")

keygen clj/s macro

(keygen & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (keygen "hello") (keygen nil "hello")

These two are made equivalent at compile time (keygen {:onClick f} "hello") (keygen #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (keygen :#the-id.klass.other-klass "hello") (keygen :#the-id.klass.other-klass {:onClick f} "hello")

label clj/s macro

(label & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (label "hello") (label nil "hello")

These two are made equivalent at compile time (label {:onClick f} "hello") (label #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (label :#the-id.klass.other-klass "hello") (label :#the-id.klass.other-klass {:onClick f} "hello")

legend clj/s macro

(legend & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (legend "hello") (legend nil "hello")

These two are made equivalent at compile time (legend {:onClick f} "hello") (legend #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (legend :#the-id.klass.other-klass "hello") (legend :#the-id.klass.other-klass {:onClick f} "hello")

li clj/s macro

(li & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (li "hello") (li nil "hello")

These two are made equivalent at compile time (li {:onClick f} "hello") (li #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (li :#the-id.klass.other-klass "hello") (li :#the-id.klass.other-klass {:onClick f} "hello")

line clj/s macro

(line & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (line "hello") (line nil "hello")

These two are made equivalent at compile time (line {:onClick f} "hello") (line #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (line :#the-id.klass.other-klass "hello") (line :#the-id.klass.other-klass {:onClick f} "hello")

linearGradient clj/s macro

(linearGradient & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (linearGradient "hello") (linearGradient nil "hello")

These two are made equivalent at compile time (linearGradient {:onClick f} "hello") (linearGradient #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (linearGradient :#the-id.klass.other-klass "hello") (linearGradient :#the-id.klass.other-klass {:onClick f} "hello")

link clj/s macro

(link & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (link "hello") (link nil "hello")

These two are made equivalent at compile time (link {:onClick f} "hello") (link #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (link :#the-id.klass.other-klass "hello") (link :#the-id.klass.other-klass {:onClick f} "hello")

macro-create-element cljs

(macro-create-element type args)

(macro-create-element type args csskw)

Runtime interpretation of props. Used internally by element generation when the macro cannot expand the element at compile time.

macro-create-element* cljs

(macro-create-element* arr)

Used internally by the DOM element generation.

macro-create-wrapped-form-element cljs

(macro-create-wrapped-form-element opts)

Used internally by element generation.

main clj/s macro

(main & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (main "hello") (main nil "hello")

These two are made equivalent at compile time (main {:onClick f} "hello") (main #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (main :#the-id.klass.other-klass "hello") (main :#the-id.klass.other-klass {:onClick f} "hello")

map clj/s macro

(map & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (map "hello") (map nil "hello")

These two are made equivalent at compile time (map {:onClick f} "hello") (map #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (map :#the-id.klass.other-klass "hello") (map :#the-id.klass.other-klass {:onClick f} "hello")

mark clj/s macro

(mark & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mark "hello") (mark nil "hello")

These two are made equivalent at compile time (mark {:onClick f} "hello") (mark #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mark :#the-id.klass.other-klass "hello") (mark :#the-id.klass.other-klass {:onClick f} "hello")

mask clj/s macro

(mask & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mask "hello") (mask nil "hello")

These two are made equivalent at compile time (mask {:onClick f} "hello") (mask #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mask :#the-id.klass.other-klass "hello") (mask :#the-id.klass.other-klass {:onClick f} "hello")

menu clj/s macro

(menu & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (menu "hello") (menu nil "hello")

These two are made equivalent at compile time (menu {:onClick f} "hello") (menu #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (menu :#the-id.klass.other-klass "hello") (menu :#the-id.klass.other-klass {:onClick f} "hello")

menuitem clj/s macro

(menuitem & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (menuitem "hello") (menuitem nil "hello")

These two are made equivalent at compile time (menuitem {:onClick f} "hello") (menuitem #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (menuitem :#the-id.klass.other-klass "hello") (menuitem :#the-id.klass.other-klass {:onClick f} "hello")

meta clj/s macro

(meta & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meta "hello") (meta nil "hello")

These two are made equivalent at compile time (meta {:onClick f} "hello") (meta #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meta :#the-id.klass.other-klass "hello") (meta :#the-id.klass.other-klass {:onClick f} "hello")

meter clj/s macro

(meter & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meter "hello") (meter nil "hello")

These two are made equivalent at compile time (meter {:onClick f} "hello") (meter #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meter :#the-id.klass.other-klass "hello") (meter :#the-id.klass.other-klass {:onClick f} "hello")

nav clj/s macro

(nav & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (nav "hello") (nav nil "hello")

These two are made equivalent at compile time (nav {:onClick f} "hello") (nav #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (nav :#the-id.klass.other-klass "hello") (nav :#the-id.klass.other-klass {:onClick f} "hello")

node cljs

(node component)

(node component name)

Returns the dom node associated with a component's React ref.

noscript clj/s macro

(noscript & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (noscript "hello") (noscript nil "hello")

These two are made equivalent at compile time (noscript {:onClick f} "hello") (noscript #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (noscript :#the-id.klass.other-klass "hello") (noscript :#the-id.klass.other-klass {:onClick f} "hello")

object clj/s macro

(object & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (object "hello") (object nil "hello")

These two are made equivalent at compile time (object {:onClick f} "hello") (object #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (object :#the-id.klass.other-klass "hello") (object :#the-id.klass.other-klass {:onClick f} "hello")

ol clj/s macro

(ol & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ol "hello") (ol nil "hello")

These two are made equivalent at compile time (ol {:onClick f} "hello") (ol #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ol :#the-id.klass.other-klass "hello") (ol :#the-id.klass.other-klass {:onClick f} "hello")

optgroup clj/s macro

(optgroup & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (optgroup "hello") (optgroup nil "hello")

These two are made equivalent at compile time (optgroup {:onClick f} "hello") (optgroup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (optgroup :#the-id.klass.other-klass "hello") (optgroup :#the-id.klass.other-klass {:onClick f} "hello")

option clj/s macro

(option & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (option "hello") (option nil "hello")

These two are made equivalent at compile time (option {:onClick f} "hello") (option #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (option :#the-id.klass.other-klass "hello") (option :#the-id.klass.other-klass {:onClick f} "hello")

output clj/s macro

(output & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (output "hello") (output nil "hello")

These two are made equivalent at compile time (output {:onClick f} "hello") (output #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (output :#the-id.klass.other-klass "hello") (output :#the-id.klass.other-klass {:onClick f} "hello")

p clj/s macro

(p & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (p "hello") (p nil "hello")

These two are made equivalent at compile time (p {:onClick f} "hello") (p #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (p :#the-id.klass.other-klass "hello") (p :#the-id.klass.other-klass {:onClick f} "hello")

param clj/s macro

(param & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (param "hello") (param nil "hello")

These two are made equivalent at compile time (param {:onClick f} "hello") (param #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (param :#the-id.klass.other-klass "hello") (param :#the-id.klass.other-klass {:onClick f} "hello")

path clj/s macro

(path & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (path "hello") (path nil "hello")

These two are made equivalent at compile time (path {:onClick f} "hello") (path #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (path :#the-id.klass.other-klass "hello") (path :#the-id.klass.other-klass {:onClick f} "hello")

pattern clj/s macro

(pattern & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (pattern "hello") (pattern nil "hello")

These two are made equivalent at compile time (pattern {:onClick f} "hello") (pattern #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (pattern :#the-id.klass.other-klass "hello") (pattern :#the-id.klass.other-klass {:onClick f} "hello")

picture clj/s macro

(picture & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (picture "hello") (picture nil "hello")

These two are made equivalent at compile time (picture {:onClick f} "hello") (picture #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (picture :#the-id.klass.other-klass "hello") (picture :#the-id.klass.other-klass {:onClick f} "hello")

polygon clj/s macro

(polygon & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (polygon "hello") (polygon nil "hello")

These two are made equivalent at compile time (polygon {:onClick f} "hello") (polygon #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (polygon :#the-id.klass.other-klass "hello") (polygon :#the-id.klass.other-klass {:onClick f} "hello")

polyline clj/s macro

(polyline & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (polyline "hello") (polyline nil "hello")

These two are made equivalent at compile time (polyline {:onClick f} "hello") (polyline #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (polyline :#the-id.klass.other-klass "hello") (polyline :#the-id.klass.other-klass {:onClick f} "hello")

pre clj/s macro

(pre & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (pre "hello") (pre nil "hello")

These two are made equivalent at compile time (pre {:onClick f} "hello") (pre #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (pre :#the-id.klass.other-klass "hello") (pre :#the-id.klass.other-klass {:onClick f} "hello")

progress clj/s macro

(progress & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (progress "hello") (progress nil "hello")

These two are made equivalent at compile time (progress {:onClick f} "hello") (progress #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (progress :#the-id.klass.other-klass "hello") (progress :#the-id.klass.other-klass {:onClick f} "hello")

q clj/s macro

(q & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (q "hello") (q nil "hello")

These two are made equivalent at compile time (q {:onClick f} "hello") (q #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (q :#the-id.klass.other-klass "hello") (q :#the-id.klass.other-klass {:onClick f} "hello")

radialGradient clj/s macro

(radialGradient & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (radialGradient "hello") (radialGradient nil "hello")

These two are made equivalent at compile time (radialGradient {:onClick f} "hello") (radialGradient #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (radialGradient :#the-id.klass.other-klass "hello") (radialGradient :#the-id.klass.other-klass {:onClick f} "hello")

rect clj/s macro

(rect & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rect "hello") (rect nil "hello")

These two are made equivalent at compile time (rect {:onClick f} "hello") (rect #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rect :#the-id.klass.other-klass "hello") (rect :#the-id.klass.other-klass {:onClick f} "hello")

render cljs

(render component el)

Equivalent to React.render

render-to-str cljs

(render-to-str c)

Equivalent to React.renderToString

rp clj/s macro

(rp & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rp "hello") (rp nil "hello")

These two are made equivalent at compile time (rp {:onClick f} "hello") (rp #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rp :#the-id.klass.other-klass "hello") (rp :#the-id.klass.other-klass {:onClick f} "hello")

rt clj/s macro

(rt & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rt "hello") (rt nil "hello")

These two are made equivalent at compile time (rt {:onClick f} "hello") (rt #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rt :#the-id.klass.other-klass "hello") (rt :#the-id.klass.other-klass {:onClick f} "hello")

ruby clj/s macro

(ruby & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ruby "hello") (ruby nil "hello")

These two are made equivalent at compile time (ruby {:onClick f} "hello") (ruby #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ruby :#the-id.klass.other-klass "hello") (ruby :#the-id.klass.other-klass {:onClick f} "hello")

s clj/s macro

(s & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (s "hello") (s nil "hello")

These two are made equivalent at compile time (s {:onClick f} "hello") (s #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (s :#the-id.klass.other-klass "hello") (s :#the-id.klass.other-klass {:onClick f} "hello")

samp clj/s macro

(samp & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (samp "hello") (samp nil "hello")

These two are made equivalent at compile time (samp {:onClick f} "hello") (samp #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (samp :#the-id.klass.other-klass "hello") (samp :#the-id.klass.other-klass {:onClick f} "hello")

script clj/s macro

(script & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (script "hello") (script nil "hello")

These two are made equivalent at compile time (script {:onClick f} "hello") (script #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (script :#the-id.klass.other-klass "hello") (script :#the-id.klass.other-klass {:onClick f} "hello")

section clj/s macro

(section & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (section "hello") (section nil "hello")

These two are made equivalent at compile time (section {:onClick f} "hello") (section #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (section :#the-id.klass.other-klass "hello") (section :#the-id.klass.other-klass {:onClick f} "hello")

select clj/s macro

(select & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (select "hello") (select nil "hello")

These two are made equivalent at compile time (select {:onClick f} "hello") (select #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (select :#the-id.klass.other-klass "hello") (select :#the-id.klass.other-klass {:onClick f} "hello")

small clj/s macro

(small & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (small "hello") (small nil "hello")

These two are made equivalent at compile time (small {:onClick f} "hello") (small #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (small :#the-id.klass.other-klass "hello") (small :#the-id.klass.other-klass {:onClick f} "hello")

source clj/s macro

(source & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (source "hello") (source nil "hello")

These two are made equivalent at compile time (source {:onClick f} "hello") (source #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (source :#the-id.klass.other-klass "hello") (source :#the-id.klass.other-klass {:onClick f} "hello")

span clj/s macro

(span & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (span "hello") (span nil "hello")

These two are made equivalent at compile time (span {:onClick f} "hello") (span #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (span :#the-id.klass.other-klass "hello") (span :#the-id.klass.other-klass {:onClick f} "hello")

stop clj/s macro

(stop & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (stop "hello") (stop nil "hello")

These two are made equivalent at compile time (stop {:onClick f} "hello") (stop #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (stop :#the-id.klass.other-klass "hello") (stop :#the-id.klass.other-klass {:onClick f} "hello")

strong clj/s macro

(strong & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (strong "hello") (strong nil "hello")

These two are made equivalent at compile time (strong {:onClick f} "hello") (strong #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (strong :#the-id.klass.other-klass "hello") (strong :#the-id.klass.other-klass {:onClick f} "hello")

style clj/s macro

(style & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (style "hello") (style nil "hello")

These two are made equivalent at compile time (style {:onClick f} "hello") (style #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (style :#the-id.klass.other-klass "hello") (style :#the-id.klass.other-klass {:onClick f} "hello")

sub clj/s macro

(sub & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (sub "hello") (sub nil "hello")

These two are made equivalent at compile time (sub {:onClick f} "hello") (sub #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (sub :#the-id.klass.other-klass "hello") (sub :#the-id.klass.other-klass {:onClick f} "hello")

summary clj/s macro

(summary & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (summary "hello") (summary nil "hello")

These two are made equivalent at compile time (summary {:onClick f} "hello") (summary #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (summary :#the-id.klass.other-klass "hello") (summary :#the-id.klass.other-klass {:onClick f} "hello")

sup clj/s macro

(sup & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (sup "hello") (sup nil "hello")

These two are made equivalent at compile time (sup {:onClick f} "hello") (sup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (sup :#the-id.klass.other-klass "hello") (sup :#the-id.klass.other-klass {:onClick f} "hello")

svg clj/s macro

(svg & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (svg "hello") (svg nil "hello")

These two are made equivalent at compile time (svg {:onClick f} "hello") (svg #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (svg :#the-id.klass.other-klass "hello") (svg :#the-id.klass.other-klass {:onClick f} "hello")

syntax-error clj

(syntax-error and-form ex)

Format a DOM syntax error

table clj/s macro

(table & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (table "hello") (table nil "hello")

These two are made equivalent at compile time (table {:onClick f} "hello") (table #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (table :#the-id.klass.other-klass "hello") (table :#the-id.klass.other-klass {:onClick f} "hello")

tbody clj/s macro

(tbody & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tbody "hello") (tbody nil "hello")

These two are made equivalent at compile time (tbody {:onClick f} "hello") (tbody #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tbody :#the-id.klass.other-klass "hello") (tbody :#the-id.klass.other-klass {:onClick f} "hello")

td clj/s macro

(td & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (td "hello") (td nil "hello")

These two are made equivalent at compile time (td {:onClick f} "hello") (td #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (td :#the-id.klass.other-klass "hello") (td :#the-id.klass.other-klass {:onClick f} "hello")

text clj/s macro

(text & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (text "hello") (text nil "hello")

These two are made equivalent at compile time (text {:onClick f} "hello") (text #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (text :#the-id.klass.other-klass "hello") (text :#the-id.klass.other-klass {:onClick f} "hello")

textarea clj/s macro

(textarea & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (textarea "hello") (textarea nil "hello")

These two are made equivalent at compile time (textarea {:onClick f} "hello") (textarea #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (textarea :#the-id.klass.other-klass "hello") (textarea :#the-id.klass.other-klass {:onClick f} "hello")

tfoot clj/s macro

(tfoot & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tfoot "hello") (tfoot nil "hello")

These two are made equivalent at compile time (tfoot {:onClick f} "hello") (tfoot #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tfoot :#the-id.klass.other-klass "hello") (tfoot :#the-id.klass.other-klass {:onClick f} "hello")

th clj/s macro

(th & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (th "hello") (th nil "hello")

These two are made equivalent at compile time (th {:onClick f} "hello") (th #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (th :#the-id.klass.other-klass "hello") (th :#the-id.klass.other-klass {:onClick f} "hello")

thead clj/s macro

(thead & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (thead "hello") (thead nil "hello")

These two are made equivalent at compile time (thead {:onClick f} "hello") (thead #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (thead :#the-id.klass.other-klass "hello") (thead :#the-id.klass.other-klass {:onClick f} "hello")

time clj/s macro

(time & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (time "hello") (time nil "hello")

These two are made equivalent at compile time (time {:onClick f} "hello") (time #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (time :#the-id.klass.other-klass "hello") (time :#the-id.klass.other-klass {:onClick f} "hello")

title clj/s macro

(title & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (title "hello") (title nil "hello")

These two are made equivalent at compile time (title {:onClick f} "hello") (title #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (title :#the-id.klass.other-klass "hello") (title :#the-id.klass.other-klass {:onClick f} "hello")

tr clj/s macro

(tr & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tr "hello") (tr nil "hello")

These two are made equivalent at compile time (tr {:onClick f} "hello") (tr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tr :#the-id.klass.other-klass "hello") (tr :#the-id.klass.other-klass {:onClick f} "hello")

track clj/s macro

(track & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (track "hello") (track nil "hello")

These two are made equivalent at compile time (track {:onClick f} "hello") (track #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (track :#the-id.klass.other-klass "hello") (track :#the-id.klass.other-klass {:onClick f} "hello")

tspan clj/s macro

(tspan & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tspan "hello") (tspan nil "hello")

These two are made equivalent at compile time (tspan {:onClick f} "hello") (tspan #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tspan :#the-id.klass.other-klass "hello") (tspan :#the-id.klass.other-klass {:onClick f} "hello")

u clj/s macro

(u & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (u "hello") (u nil "hello")

These two are made equivalent at compile time (u {:onClick f} "hello") (u #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (u :#the-id.klass.other-klass "hello") (u :#the-id.klass.other-klass {:onClick f} "hello")

ul clj/s macro

(ul & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ul "hello") (ul nil "hello")

These two are made equivalent at compile time (ul {:onClick f} "hello") (ul #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ul :#the-id.klass.other-klass "hello") (ul :#the-id.klass.other-klass {:onClick f} "hello")

use clj/s macro

(use & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (use "hello") (use nil "hello")

These two are made equivalent at compile time (use {:onClick f} "hello") (use #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (use :#the-id.klass.other-klass "hello") (use :#the-id.klass.other-klass {:onClick f} "hello")

var clj/s macro

(var & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (var "hello") (var nil "hello")

These two are made equivalent at compile time (var {:onClick f} "hello") (var #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (var :#the-id.klass.other-klass "hello") (var :#the-id.klass.other-klass {:onClick f} "hello")

video clj/s macro

(video & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (video "hello") (video nil "hello")

These two are made equivalent at compile time (video {:onClick f} "hello") (video #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (video :#the-id.klass.other-klass "hello") (video :#the-id.klass.other-klass {:onClick f} "hello")

wbr clj/s macro

(wbr & args)

Returns a React DOM element. Can be invoked in several ways

These two are made equivalent at compile time (wbr "hello") (wbr nil "hello")

These two are made equivalent at compile time (wbr {:onClick f} "hello") (wbr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (wbr :#the-id.klass.other-klass "hello") (wbr :#the-id.klass.other-klass {:onClick f} "hello")

wrap-form-element cljs

(wrap-form-element element)

wrapped-input cljs

Low-level form input, with no syntactic sugar. Used internally by DOM macros

wrapped-option cljs

Low-level form input, with no syntactic sugar. Used internally by DOM macros

wrapped-select cljs

Low-level form input, with no syntactic sugar. Used internally by DOM macros

wrapped-textarea cljs

Low-level form input, with no syntactic sugar. Used internally by DOM macros