Liking cljdoc? Tell your friends :D
Mostly clj/s.
Exceptions indicated.

com.fulcrologic.fulcro.dom

clj

MACROS for generating CLJS code. See dom.cljs. There are both CLJ and CLJS versions of this file, but both are form CLJS. The CLJ file is necessary because macros in CLJS are expanded at compile time in the JVM. There is no way to get macros and functions that work properly for both CLJ and CLJS output, so in order to get both a macro and function that is usable in CLJ and CLJS there need to be two namespaces. The DOM macros/functions that work for CLJ are in dom-server.

Thus, if you are using these in a CLJC file, you MUST require them like this:

(ns my-thing.ui
  (:require
    #?(:clj [com.fulcrologic.fulcro.dom-server :as dom]
       :cljs [com.fulcrologic.fulcro.dom :as dom])))

This is a limitation of the operation of the language itself (if you want both macros for performance in CLJ and CLJS (expanded at compile time to optimal form) as well as function versions for use as lambdas).

MACROS for generating CLJS code. See dom.cljs. There are both CLJ and CLJS versions of this file, but *both* are
form CLJS. The CLJ file is necessary because macros in CLJS are expanded at compile time in the JVM. There is
no way to get macros and functions that work properly for both CLJ and CLJS output, so in order to get
both a macro and function that is usable in CLJ and CLJS there need to be two namespaces. The DOM macros/functions
that work for CLJ are in `dom-server`.

Thus, if you are using these in a CLJC file, you MUST require them like this:

```
(ns my-thing.ui
  (:require
    #?(:clj [com.fulcrologic.fulcro.dom-server :as dom]
       :cljs [com.fulcrologic.fulcro.dom :as dom])))
```

This is a limitation of the operation of the language itself (if you want both macros for performance in CLJ and CLJS
(expanded at compile time to optimal form) as well as function versions for use as lambdas).
cljs

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

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

aclj/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")

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")
source (clj)source (cljs)raw docstring

abbrclj/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")

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")
source (clj)source (cljs)raw docstring

addressclj/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")

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")
source (clj)source (cljs)raw docstring

altGlyphclj/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")

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")
source (clj)source (cljs)raw docstring

altGlyphDefclj/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")

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")
source (clj)source (cljs)raw docstring

altGlyphItemclj/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")

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")
source (clj)source (cljs)raw docstring

animateclj/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")

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")
source (clj)source (cljs)raw docstring

animateColorclj/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")

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")
source (clj)source (cljs)raw docstring

animateMotionclj/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")

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")
source (clj)source (cljs)raw docstring

animateTransformclj/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")

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")
source (clj)source (cljs)raw docstring

annotate-with-source-attributesclj

(annotate-with-source-attributes env form attrs-type attrs-expr)
source

areaclj/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")

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")
source (clj)source (cljs)raw docstring

articleclj/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")

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")
source (clj)source (cljs)raw docstring

asideclj/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")

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")
source (clj)source (cljs)raw docstring

audioclj/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")

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")
source (clj)source (cljs)raw docstring

bclj/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")

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")
source (clj)source (cljs)raw docstring

baseclj/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")

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")
source (clj)source (cljs)raw docstring

bdiclj/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")

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")
source (clj)source (cljs)raw docstring

bdoclj/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")

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")
source (clj)source (cljs)raw docstring

bigclj/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")

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")
source (clj)source (cljs)raw docstring

blockquoteclj/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")

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")
source (clj)source (cljs)raw docstring

bodyclj/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")

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")
source (clj)source (cljs)raw docstring

brclj/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")

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")
source (clj)source (cljs)raw docstring

buttonclj/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")

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")
source (clj)source (cljs)raw docstring

canvasclj/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")

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")
source (clj)source (cljs)raw docstring

captionclj/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")

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")
source (clj)source (cljs)raw docstring

child->typed-childcljs

(child->typed-child child)
source

circleclj/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")

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")
source (clj)source (cljs)raw docstring

citeclj/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")

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")
source (clj)source (cljs)raw docstring

clipPathclj/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")

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")
source (clj)source (cljs)raw docstring

clj-map->js-objectclj

(clj-map->js-object m)

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

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

codeclj/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")

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")
source (clj)source (cljs)raw docstring

colclj/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")

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")
source (clj)source (cljs)raw docstring

colgroupclj/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")

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")
source (clj)source (cljs)raw docstring

color-profileclj/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")

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")
source (clj)source (cljs)raw docstring

convert-propscljs

(convert-props props)

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

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

create-elementcljs

(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

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`
sourceraw docstring

cursorclj/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")

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")
source (clj)source (cljs)raw docstring

dataclj/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")

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")
source (clj)source (cljs)raw docstring

datalistclj/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")

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")
source (clj)source (cljs)raw docstring

ddclj/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")

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")
source (clj)source (cljs)raw docstring

defsclj/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")

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")
source (clj)source (cljs)raw docstring

delclj/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")

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")
source (clj)source (cljs)raw docstring

descclj/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")

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")
source (clj)source (cljs)raw docstring

detailsclj/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")

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")
source (clj)source (cljs)raw docstring

dfnclj/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")

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")
source (clj)source (cljs)raw docstring

dialogclj/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")

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")
source (clj)source (cljs)raw docstring

discardclj/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")

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")
source (clj)source (cljs)raw docstring

divclj/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")

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")
source (clj)source (cljs)raw docstring

dlclj/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")

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")
source (clj)source (cljs)raw docstring

dtclj/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")

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")
source (clj)source (cljs)raw docstring

element?cljs

(element? x)

Returns true if the given arg is a react element.

Returns true if the given arg is a react element.
sourceraw docstring

ellipseclj/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")

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")
source (clj)source (cljs)raw docstring

emclj/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")

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")
source (clj)source (cljs)raw docstring

embedclj/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")

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")
source (clj)source (cljs)raw docstring

emit-fulcro-source-annotations?clj

(emit-fulcro-source-annotations?)
source

emit-tagclj

(emit-tag str-tag-name args & [env form])

PRIVATE. DO NOT USE.

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

PRIVATE.  DO NOT USE.

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

emit-tag-unwrappedclj

(emit-tag-unwrapped str-tag-name args & [env form])

PRIVATE. DO NOT USE. Same as emit-tag, but does no wrap inputs.

PRIVATE.  DO NOT USE. Same as emit-tag, but does no wrap inputs.
sourceraw docstring

feBlendclj/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")

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")
source (clj)source (cljs)raw docstring

feColorMatrixclj/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")

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")
source (clj)source (cljs)raw docstring

feComponentTransferclj/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")

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")
source (clj)source (cljs)raw docstring

feCompositeclj/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")

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")
source (clj)source (cljs)raw docstring

feConvolveMatrixclj/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")

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")
source (clj)source (cljs)raw docstring

feDiffuseLightingclj/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")

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")
source (clj)source (cljs)raw docstring

feDisplacementMapclj/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")

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")
source (clj)source (cljs)raw docstring

feDistantLightclj/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")

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")
source (clj)source (cljs)raw docstring

feDropShadowclj/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")

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")
source (clj)source (cljs)raw docstring

feFloodclj/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")

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")
source (clj)source (cljs)raw docstring

feFuncAclj/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")

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")
source (clj)source (cljs)raw docstring

feFuncBclj/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")

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")
source (clj)source (cljs)raw docstring

feFuncGclj/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")

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")
source (clj)source (cljs)raw docstring

feFuncRclj/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")

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")
source (clj)source (cljs)raw docstring

feGaussianBlurclj/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")

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")
source (clj)source (cljs)raw docstring

feImageclj/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")

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")
source (clj)source (cljs)raw docstring

feMergeclj/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")

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")
source (clj)source (cljs)raw docstring

feMergeNodeclj/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")

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")
source (clj)source (cljs)raw docstring

feMorphologyclj/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")

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")
source (clj)source (cljs)raw docstring

feOffsetclj/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")

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")
source (clj)source (cljs)raw docstring

fePointLightclj/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")

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")
source (clj)source (cljs)raw docstring

feSpecularLightingclj/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")

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")
source (clj)source (cljs)raw docstring

feSpotLightclj/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")

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")
source (clj)source (cljs)raw docstring

feTileclj/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")

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")
source (clj)source (cljs)raw docstring

feTurbulenceclj/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")

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")
source (clj)source (cljs)raw docstring

fieldsetclj/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")

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")
source (clj)source (cljs)raw docstring

figcaptionclj/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")

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")
source (clj)source (cljs)raw docstring

figureclj/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")

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")
source (clj)source (cljs)raw docstring

filterclj/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")

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")
source (clj)source (cljs)raw docstring

fontclj/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")

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")
source (clj)source (cljs)raw docstring

font-faceclj/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")

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")
source (clj)source (cljs)raw docstring

font-face-formatclj/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")

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")
source (clj)source (cljs)raw docstring

font-face-nameclj/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")

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")
source (clj)source (cljs)raw docstring

font-face-srcclj/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")

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")
source (clj)source (cljs)raw docstring

font-face-uriclj/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")

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

foreignObjectclj/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")

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")
source (clj)source (cljs)raw docstring

formclj/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")

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")
source (clj)source (cljs)raw docstring

form-elements?cljs

source

gclj/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")

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")
source (clj)source (cljs)raw docstring

gen-client-dom-fnsclj/smacro

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

gen-dom-macroclj

(gen-dom-macro emitter name)
source

gen-dom-macrosclj/smacro

(gen-dom-macros emitter)
(gen-dom-macros emitter unwrapped-emitter)
source

glyphclj/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")

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")
source (clj)source (cljs)raw docstring

glyphRefclj/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")

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")
source (clj)source (cljs)raw docstring

h1clj/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")

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")
source (clj)source (cljs)raw docstring

h2clj/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")

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")
source (clj)source (cljs)raw docstring

h3clj/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")

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")
source (clj)source (cljs)raw docstring

h4clj/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")

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")
source (clj)source (cljs)raw docstring

h5clj/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")

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")
source (clj)source (cljs)raw docstring

h6clj/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")

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")
source (clj)source (cljs)raw docstring

hatchclj/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")

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")
source (clj)source (cljs)raw docstring

hatchpathclj/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")

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

hkernclj/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")

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")
source (clj)source (cljs)raw docstring

hrclj/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")

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")
source (clj)source (cljs)raw docstring

htmlclj/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")

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")
source (clj)source (cljs)raw docstring

iclj/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")

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")
source (clj)source (cljs)raw docstring

iframeclj/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")

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")
source (clj)source (cljs)raw docstring

imageclj/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")

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")
source (clj)source (cljs)raw docstring

imgclj/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")

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")
source (clj)source (cljs)raw docstring

Inputcljs

React component that wraps dom/input to prevent cursor madness.

React component that wraps dom/input to prevent cursor madness.
sourceraw docstring

inputclj/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")

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")
source (clj)source (cljs)raw docstring

insclj/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")

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")
source (clj)source (cljs)raw docstring

is-form-element?cljs

(is-form-element? element)
source

kbdclj/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")

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")
source (clj)source (cljs)raw docstring

keygenclj/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")

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")
source (clj)source (cljs)raw docstring

labelclj/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")

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")
source (clj)source (cljs)raw docstring

legendclj/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")

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")
source (clj)source (cljs)raw docstring

liclj/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")

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")
source (clj)source (cljs)raw docstring

lineclj/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")

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")
source (clj)source (cljs)raw docstring

linearGradientclj/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")

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

macro-create-elementcljs

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

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

macro-create-element*cljs

(macro-create-element* arr)

Used internally by the DOM element generation.

Used internally by the DOM element generation.
sourceraw docstring

macro-create-unwrapped-elementcljs

(macro-create-unwrapped-element type args)
(macro-create-unwrapped-element type args csskw)

Just like macro-create-element, but never wraps form input types.

Just like macro-create-element, but never wraps form input types.
sourceraw docstring

macro-create-wrapped-form-elementcljs

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

Used internally by element generation.

Used internally by element generation.
sourceraw docstring

mainclj/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")

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")
source (clj)source (cljs)raw docstring

mapclj/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")

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")
source (clj)source (cljs)raw docstring

markclj/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")

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")
source (clj)source (cljs)raw docstring

markerclj/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")

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")
source (clj)source (cljs)raw docstring

maskclj/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")

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

meshclj/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")

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")
source (clj)source (cljs)raw docstring

meshgradientclj/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")

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")
source (clj)source (cljs)raw docstring

meshpatchclj/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")

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")
source (clj)source (cljs)raw docstring

meshrowclj/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")

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")
source (clj)source (cljs)raw docstring

metaclj/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")

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")
source (clj)source (cljs)raw docstring

metadataclj/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")

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")
source (clj)source (cljs)raw docstring

meterclj/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")

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")
source (clj)source (cljs)raw docstring

missing-glyphclj/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")

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")
source (clj)source (cljs)raw docstring

mpathclj/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")

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")
source (clj)source (cljs)raw docstring

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

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")
source (clj)source (cljs)raw docstring

nodecljs

(node component)
(node component name)

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

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

noscriptclj/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")

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")
source (clj)source (cljs)raw docstring

objectclj/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")

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")
source (clj)source (cljs)raw docstring

olclj/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")

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")
source (clj)source (cljs)raw docstring

optgroupclj/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")

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")
source (clj)source (cljs)raw docstring

optionclj/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")

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")
source (clj)source (cljs)raw docstring

outputclj/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")

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")
source (clj)source (cljs)raw docstring

pclj/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")

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")
source (clj)source (cljs)raw docstring

paramclj/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")

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")
source (clj)source (cljs)raw docstring

parse-argscljs

(parse-args args)

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

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

pathclj/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")

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")
source (clj)source (cljs)raw docstring

patternclj/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")

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")
source (clj)source (cljs)raw docstring

pictureclj/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")

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")
source (clj)source (cljs)raw docstring

polygonclj/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")

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")
source (clj)source (cljs)raw docstring

polylineclj/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")

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")
source (clj)source (cljs)raw docstring

preclj/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")

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")
source (clj)source (cljs)raw docstring

progressclj/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")

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")
source (clj)source (cljs)raw docstring

qclj/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")

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")
source (clj)source (cljs)raw docstring

radialGradientclj/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")

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")
source (clj)source (cljs)raw docstring

rectclj/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")

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")
source (clj)source (cljs)raw docstring

rendercljs

(render component el)

Equivalent to React.render

Equivalent to React.render
sourceraw docstring

render-to-strcljsdeprecated

(render-to-str c)

This fn is outdated - it expects js/ReactDOMServer to be defined (used to be provided cljsjs.react.dom.server). It is better to do it yourself (under shadow-cljs):

(ns ex (:require ["react-dom/server" :as react-dom-server] ...))
(react-dom-server/renderToString c)
This fn is outdated - it expects js/ReactDOMServer to be defined (used to be provided cljsjs.react.dom.server).
It is better to do it yourself (under shadow-cljs):

 ```clj
 (ns ex (:require ["react-dom/server" :as react-dom-server] ...))
 (react-dom-server/renderToString c)
 ```
sourceraw docstring

rpclj/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")

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")
source (clj)source (cljs)raw docstring

rtclj/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")

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")
source (clj)source (cljs)raw docstring

rubyclj/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")

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")
source (clj)source (cljs)raw docstring

sclj/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")

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")
source (clj)source (cljs)raw docstring

sampclj/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")

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")
source (clj)source (cljs)raw docstring

scriptclj/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")

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")
source (clj)source (cljs)raw docstring

sectionclj/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")

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")
source (clj)source (cljs)raw docstring

selectclj/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")

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")
source (clj)source (cljs)raw docstring

setclj/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")

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")
source (clj)source (cljs)raw docstring

smallclj/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")

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)source (cljs)raw docstring

solidcolorclj/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")

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)source (cljs)raw docstring

sourceclj/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")

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")
source (clj)source (cljs)raw docstring

spanclj/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")

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")
source (clj)source (cljs)raw docstring

stopclj/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")

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")
source (clj)source (cljs)raw docstring

strongclj/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")

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")
source (clj)source (cljs)raw docstring

styleclj/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")

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")
source (clj)source (cljs)raw docstring

subclj/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")

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")
source (clj)source (cljs)raw docstring

summaryclj/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")

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")
source (clj)source (cljs)raw docstring

supclj/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")

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")
source (clj)source (cljs)raw docstring

svgclj/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")

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")
source (clj)source (cljs)raw docstring

switchclj/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")

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")
source (clj)source (cljs)raw docstring

symbolclj/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")

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")
source (clj)source (cljs)raw docstring

syntax-errorclj

(syntax-error and-form ex)

Format a DOM syntax error

Format a DOM syntax error
sourceraw docstring

tableclj/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")

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")
source (clj)source (cljs)raw docstring

tbodyclj/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")

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")
source (clj)source (cljs)raw docstring

tdclj/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")

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")
source (clj)source (cljs)raw docstring

textclj/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")

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")
source (clj)source (cljs)raw docstring

textareaclj/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")

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")
source (clj)source (cljs)raw docstring

textPathclj/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")

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")
source (clj)source (cljs)raw docstring

tfootclj/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")

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")
source (clj)source (cljs)raw docstring

thclj/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")

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")
source (clj)source (cljs)raw docstring

theadclj/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")

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")
source (clj)source (cljs)raw docstring

timeclj/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")

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")
source (clj)source (cljs)raw docstring

titleclj/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")

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")
source (clj)source (cljs)raw docstring

trclj/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")

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")
source (clj)source (cljs)raw docstring

trackclj/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")

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")
source (clj)source (cljs)raw docstring

trefclj/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")

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")
source (clj)source (cljs)raw docstring

tspanclj/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")

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")
source (clj)source (cljs)raw docstring

uclj/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")

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")
source (clj)source (cljs)raw docstring

ui-inputcljs

A wrapped input. Use this when you see the cursor jump around while you're trying to type in an input. Drop-in replacement for dom/input.

NOTE: The onChange and onBlur handlers will receive a string value, not an event. If you want the raw event on changes use onInput.

A wrapped input. Use this when you see the cursor jump around while you're trying to type in an input. Drop-in replacement
for `dom/input`.

NOTE: The onChange and onBlur handlers will receive a string value, not an event. If you want the raw event on changes use onInput.
sourceraw docstring

ulclj/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")

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")
source (clj)source (cljs)raw docstring

unknownclj/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")

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")
source (clj)source (cljs)raw docstring

useclj/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")

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")
source (clj)source (cljs)raw docstring

varclj/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")

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")
source (clj)source (cljs)raw docstring

videoclj/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")

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")
source (clj)source (cljs)raw docstring

viewclj/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")

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")
source (clj)source (cljs)raw docstring

vkernclj/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")

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")
source (clj)source (cljs)raw docstring

wbrclj/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")

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")
source (clj)source (cljs)raw docstring

wrap-form-elementcljs

(wrap-form-element element)
source

wrap-inputs?clj

(wrap-inputs?)
source

wrapped-inputcljs

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

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

wrapped-optioncljs

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

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

wrapped-selectcljs

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

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

wrapped-textareacljs

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

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

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close