com.fulcrologic.fulcro.dom — com.fulcrologic/fulcro 3.1.8

clj

MACROS for generating CLJS code. See dom.cljs

cljs

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

a clj/s

(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

(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

(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")

altGlyph clj/s

(altGlyph & args)

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

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

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

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

altGlyphDef clj/s

(altGlyphDef & args)

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

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

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

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

altGlyphItem clj/s

(altGlyphItem & args)

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

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

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

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

animate clj/s

(animate & args)

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

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

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

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

animateColor clj/s

(animateColor & args)

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

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

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

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

animateMotion clj/s

(animateMotion & args)

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

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

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

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

animateTransform clj/s

(animateTransform & args)

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

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

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

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

area clj/s

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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")

child->typed-child cljs

(child->typed-child child)

circle clj/s

(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

(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

(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

(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

(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

(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")

color-profile clj/s

(color-profile & args)

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

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

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

There is also a shorthand for CSS id and class names (color-profile :#the-id.klass.other-klass "hello") (color-profile :#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

cursor clj/s

(cursor & args)

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

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

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

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

data clj/s

(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

(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

(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

(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

(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")

desc clj/s

(desc & args)

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

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

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

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

details clj/s

(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

(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

(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")

discard clj/s

(discard & args)

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

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

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

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

div clj/s

(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

(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

(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

(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

(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

(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")

emit-tag clj

(emit-tag str-tag-name args)

PRIVATE. DO NOT USE.

Helper function for generating CLJS DOM macros. is public for code gen problems.

feBlend clj/s

(feBlend & args)

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

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

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

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

feColorMatrix clj/s

(feColorMatrix & args)

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

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

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

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

feComponentTransfer clj/s

(feComponentTransfer & args)

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

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

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

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

feComposite clj/s

(feComposite & args)

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

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

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

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

feConvolveMatrix clj/s

(feConvolveMatrix & args)

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

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

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

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

feDiffuseLighting clj/s

(feDiffuseLighting & args)

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

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

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

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

feDisplacementMap clj/s

(feDisplacementMap & args)

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

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

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

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

feDistantLight clj/s

(feDistantLight & args)

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

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

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

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

feDropShadow clj/s

(feDropShadow & args)

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

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

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

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

feFlood clj/s

(feFlood & args)

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

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

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

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

feFuncA clj/s

(feFuncA & args)

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

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

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

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

feFuncB clj/s

(feFuncB & args)

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

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

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

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

feFuncG clj/s

(feFuncG & args)

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

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

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

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

feFuncR clj/s

(feFuncR & args)

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

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

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

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

feGaussianBlur clj/s

(feGaussianBlur & args)

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

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

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

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

feImage clj/s

(feImage & args)

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

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

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

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

feMerge clj/s

(feMerge & args)

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

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

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

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

feMergeNode clj/s

(feMergeNode & args)

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

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

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

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

feMorphology clj/s

(feMorphology & args)

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

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

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

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

feOffset clj/s

(feOffset & args)

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

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

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

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

fePointLight clj/s

(fePointLight & args)

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

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

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

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

feSpecularLighting clj/s

(feSpecularLighting & args)

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

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

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

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

feSpotLight clj/s

(feSpotLight & args)

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

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

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

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

feTile clj/s

(feTile & args)

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

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

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

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

feTurbulence clj/s

(feTurbulence & args)

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

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

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

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

fieldset clj/s

(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

(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

(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")

filter clj/s

(filter & args)

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

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

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

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

font clj/s

(font & args)

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

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

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

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

font-face clj/s

(font-face & args)

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

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

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

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

font-face-format clj/s

(font-face-format & args)

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

These two are made equivalent at compile time (font-face-format "hello") (font-face-format nil "hello")

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

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

font-face-name clj/s

(font-face-name & args)

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

These two are made equivalent at compile time (font-face-name "hello") (font-face-name nil "hello")

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

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

font-face-src clj/s

(font-face-src & args)

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

These two are made equivalent at compile time (font-face-src "hello") (font-face-src nil "hello")

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

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

font-face-uri clj/s

(font-face-uri & args)

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

These two are made equivalent at compile time (font-face-uri "hello") (font-face-uri nil "hello")

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

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

footer clj/s

(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")

foreignObject clj/s

(foreignObject & args)

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

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

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

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

form clj/s

(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

(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)

glyph clj/s

(glyph & args)

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

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

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

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

glyphRef clj/s

(glyphRef & args)

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

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

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

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

h1 clj/s

(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

(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

(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

(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

(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

(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")

hatch clj/s

(hatch & args)

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

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

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

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

hatchpath clj/s

(hatchpath & args)

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

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

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

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

head clj/s

(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

(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")

hkern clj/s

(hkern & args)

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

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

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

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

hr clj/s

(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

(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

(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

(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")

image clj/s

(image & args)

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

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

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

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

img clj/s

(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

(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

(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")

is-form-element? cljs

(is-form-element? element)

kbd clj/s

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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")

marker clj/s

(marker & args)

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

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

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

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

mask clj/s

(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

(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

(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")

mesh clj/s

(mesh & args)

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

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

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

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

meshgradient clj/s

(meshgradient & args)

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

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

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

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

meshpatch clj/s

(meshpatch & args)

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

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

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

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

meshrow clj/s

(meshrow & args)

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

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

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

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

meta clj/s

(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")

metadata clj/s

(metadata & args)

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

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

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

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

meter clj/s

(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")

missing-glyph clj/s

(missing-glyph & args)

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

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

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

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

mpath clj/s

(mpath & args)

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

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

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

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

nav clj/s

(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

(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

(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

(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

(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

(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

(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

(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

(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")

parse-args cljs

(parse-args args)

Runtime parsing of DOM tag arguments. Returns a map with keys :css, :attrs, and :children.

path clj/s

(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

(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

(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

(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

(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

(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

(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

(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

(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

(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. NOTE: You must require cljsjs.react.dom.server to use this function.

rp clj/s

(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

(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

(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

(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

(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

(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

(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

(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")

set clj/s

(set & args)

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

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

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

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

small clj/s

(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")

solidcolor clj/s

(solidcolor & args)

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

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

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

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

source clj/s

(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

(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

(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

(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

(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

(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

(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

(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

(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")

switch clj/s

(switch & args)

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

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

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

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

symbol clj/s

(symbol & args)

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

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

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

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

syntax-error clj

(syntax-error and-form ex)

Format a DOM syntax error

table clj/s

(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

(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

(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

(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

(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")

textPath clj/s

(textPath & args)

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

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

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

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

tfoot clj/s

(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

(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

(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

(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

(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

(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

(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")

tref clj/s

(tref & args)

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

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

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

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

tspan clj/s

(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

(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

(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")

unknown clj/s

(unknown & args)

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

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

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

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

use clj/s

(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

(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

(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")

view clj/s

(view & args)

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

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

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

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

vkern clj/s

(vkern & args)

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

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

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

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

wbr clj/s

(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