reagent.impl.template

*current-default-compiler*

dynamic

adapt-react-class

(adapt-react-class c)

as-element

(as-element this x fn-to-element)

cache-get

(cache-get o k)

cached-custom-prop-name

(cached-custom-prop-name k)

cached-parse

(cached-parse this x _)

cached-prop-name

(cached-prop-name k)

class-compiler

convert-custom-prop-value

(convert-custom-prop-value x)

convert-prop-value

(convert-prop-value x)

convert-props

(convert-props props id-class)

create-compiler

(create-compiler opts)

custom-kv-conv

(custom-kv-conv o k v)

custom-prop-name-cache

defc-element

(defc-element tag v)
Tag is a React function component already wrapped
with Reagent function component implementation. This function just
needs to wrap the Hiccup element children into the React element
properties and set up the optional React key if set.

expand-seq

(expand-seq s compiler)

expand-seq-check

(expand-seq-check x compiler)

expand-seq-dev

(expand-seq-dev s o compiler)

fragment-element

(fragment-element argv compiler)

function-element

(function-element tag v first-arg compiler)

hiccup-element

(hiccup-element v compiler)

hiccup-tag?

(hiccup-tag? x)

HiccupTag

kv-conv

(kv-conv o k v)

make-element

(make-element this argv component jsprops first-child)

maybe-function-element

(maybe-function-element tag v compiler)
If given tag is a Class, use it as a class,
else wrap in Reagent function wrapper.

native-element

(native-element parsed argv first compiler)

NativeWrapper

parse-tag

(parse-tag hiccup-tag)

prop-name-cache

raw-element

(raw-element comp argv compiler)

re-tag

Regular expression that parses a CSS-style id and class
from a tag name.

reag-element

(reag-element tag v compiler)

reagent-fn-component?

(reagent-fn-component? x)

set-default-compiler!

(set-default-compiler! compiler)

set-id-class

(set-id-class props id-class)
Takes the id and class from tag keyword, and adds them to the
other props. Parsed tag is JS object with :id and :class properties.

tag-name-cache

UnsafeHTML

valid-tag?

(valid-tag? x)

vec-to-elem

(vec-to-elem v compiler fn-to-element)