reagent.core

adapt-react-class

(adapt-react-class c)
Returns an adapter for a native React class, that may be used
just like a Reagent component function or class in Hiccup forms.

argv

(argv this)
Returns the entire Hiccup form passed to the component.

as-component

as-element

(as-element form)
Turns a vector of Hiccup syntax into a React element. Returns form unchanged if it is not a vector.

atom

(atom x)(atom x & rest)
Like clojure.core/atom, except that it keeps track of derefs.
Reagent components that derefs one of these are automatically
re-rendered.

children

(children this)
Returns the children passed to a component.

component-path

(component-path c)

create-class

(create-class spec)
Create a component, React style. Should be called with a map,
looking like this:
{:get-initial-state (fn [this])
:component-will-receive-props (fn [this new-argv])
:should-component-update (fn [this old-argv new-argv])
:component-will-mount (fn [this])
:component-did-mount (fn [this])
:component-will-update (fn [this new-argv])
:component-did-update (fn [this old-argv])
:component-will-unmount (fn [this])
:reagent-render (fn [args....])   ;; or :render (fn [this])
}

Everything is optional, except either :reagent-render or :render.

create-element

(create-element type)(create-element type props)(create-element type props child)(create-element type props child & children)
Create a native React element, by calling React.createElement directly.

That means the second argument must be a javascript object (or nil), and
that any Reagent hiccup forms must be processed with as-element. For example
like this:

   (r/create-element "div" #js{:className "foo"}
      "Hi " (r/as-element [:strong "world!"])

which is equivalent to

   [:div.foo "Hi" [:strong "world!"]]

current-component

(current-component)
Returns the current React component (a.k.a this) in a component
function.

cursor

(cursor src path)
Provide a cursor into a Reagent atom.

Behaves like a Reagent atom but focuses updates and derefs to
the specified path within the wrapped Reagent atom. e.g.,
  (let [c (cursor ra [:nested :content])]
    ... @c ;; equivalent to (get-in @ra [:nested :content])
    ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
    ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
    )

The first parameter can also be a function, that should look something
like this:

(defn set-get
  ([k] (get-in @state k))
  ([k v] (swap! state assoc-in k v)))

The function will be called with one argument – the path passed to
cursor – when the cursor is deref'ed, and two arguments (path and new
value) when the cursor is modified.

Given that set-get function, (and that state is a Reagent atom, or
another cursor) these cursors are equivalent:
(cursor state [:foo]) and (cursor set-get [:foo]).

dom-node

(dom-node this)
Returns the root DOM node of a mounted component.

flush

(flush)
Render dirty components immediately to the DOM.

Note that this may not work in event handlers, since React.js does
batching of updates there.

force-update

(force-update this)(force-update this deep)
Force a component to re-render immediately.

If the second argument is true, child components will also be
re-rendered, even is their arguments have not changed.

force-update-all

(force-update-all)
Force re-rendering of all mounted Reagent components. This is
probably only useful in a development environment, when you want to
update components in response to some dynamic changes to code.

Note that force-update-all may not update root components. This
happens if a component 'foo' is mounted with `(render [foo])` (since
functions are passed by value, and not by reference, in
ClojureScript). To get around this you'll have to introduce a layer
of indirection, for example by using `(render [#'foo])` instead.

is-client

merge-props

(merge-props defaults props)
Utility function that merges two maps, handling :class and :style
specially, like React's transferPropsTo.

next-tick

(next-tick f)
Run f using requestAnimationFrame or equivalent.

partial

(partial f & args)
Works just like clojure.core/partial, except that it is an IFn, and
the result can be compared with =

props

(props this)
Returns the props passed to a component.

reactify-component

(reactify-component c)
Returns an adapter for a Reagent component, that may be used from
React, for example in JSX. A single argument, props, is passed to
the component, converted to a map.

render

(render comp container)(render comp container callback)
Render a Reagent component into the DOM. The first argument may be 
either a vector (using Reagent's Hiccup syntax), or a React element. The second argument should be a DOM node.

Optionally takes a callback that is called when the component is in place.

Returns the mounted component instance.

render-component

render-component-to-string

render-to-static-markup

(render-to-static-markup component)
Turns a component into an HTML string, without data-react-id attributes, etc.

render-to-string

(render-to-string component)
Turns a component into an HTML string.

replace-state

(replace-state this new-state)
Set state of a component.
Equivalent to (reset! (state-atom this) new-state)

set-state

(set-state this new-state)
Merge component state with new-state.
Equivalent to (swap! (state-atom this) merge new-state)

state

(state this)
Returns the state of a component, as set with replace-state or set-state.
Equivalent to (deref (r/state-atom this))

state-atom

(state-atom this)
Returns an atom containing a components state.

unmount-component-at-node

(unmount-component-at-node container)
Remove a component from the given DOM node.

wrap

(wrap value reset-fn & args)
Provide a combination of value and callback, that looks like an atom.

The first argument can be any value, that will be returned when the
result is deref'ed.

The second argument should be a function, that is called with the
optional extra arguments provided to wrap, and the new value of the
resulting 'atom'.

Use for example like this:

(wrap (:foo @state)
      swap! state assoc :foo)

Probably useful only for passing to child components.