reagent.impl.template — reagent 2.0.1

*current-default-compiler* cljs

adapt-react-class cljs

(adapt-react-class c)

as-element cljs

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

cache-get cljs

(cache-get o k)

cached-custom-prop-name cljs

(cached-custom-prop-name k)

cached-parse cljs

(cached-parse this x _)

cached-prop-name cljs

(cached-prop-name k)

class-compiler cljs

convert-custom-prop-value cljs

(convert-custom-prop-value x)

convert-prop-value cljs

(convert-prop-value x)

convert-props cljs

(convert-props props id-class)

create-compiler cljs

(create-compiler opts)

custom-kv-conv cljs

(custom-kv-conv o k v)

custom-prop-name-cache cljs

defc-element cljs

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

(expand-seq s compiler)

expand-seq-check cljs

(expand-seq-check x compiler)

expand-seq-dev cljs

(expand-seq-dev s o compiler)

fragment-element cljs

(fragment-element argv compiler)

function-element cljs

(function-element tag v first-arg compiler)

hiccup-element cljs

(hiccup-element v compiler)

hiccup-tag? cljs

(hiccup-tag? x)

kv-conv cljs

(kv-conv o k v)

make-element cljs

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

maybe-function-element cljs

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

(native-element parsed argv first compiler)

parse-tag cljs

(parse-tag hiccup-tag)

prop-name-cache cljs

raw-element cljs

(raw-element comp argv compiler)

re-tag cljs

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

reag-element cljs

(reag-element tag v compiler)

reagent-fn-component? cljs

(reagent-fn-component? x)

set-default-compiler! cljs

(set-default-compiler! compiler)

set-id-class cljs

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

valid-tag? cljs

(valid-tag? x)

vec-to-elem cljs

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