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.

after-render

(after-render f)
Run f using requestAnimationFrame or equivalent.

f will be called just after any queued renders in the next animation
frame (and even if no renders actually occur).

argv

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

as-element

(as-element form)(as-element form compiler)
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.

class-names

(class-names)(class-names class)(class-names class1 class2)(class-names class1 class2 & others)
Function which normalizes and combines class values to a string

Reagent allows classes to be defined as:
- Strings
- Named objects (Symbols or Keywords)
- Collections of previous types

create-class

(create-class spec)(create-class spec compiler)
Creates JS class based on provided Clojure map, for example:

```cljs
{;; Constructor
 :constructor (fn [this props])
 :get-initial-state (fn [this])
 ;; Static methods
 :get-derived-state-from-props (fn [props state] partial-state)
 :get-derived-state-from-error (fn [error] partial-state)
 ;; Methods
 :get-snapshot-before-update (fn [this old-argv new-argv] snapshot)
 :should-component-update (fn [this old-argv new-argv])
 :component-did-mount (fn [this])
 :component-did-update (fn [this old-argv old-state snapshot])
 :component-will-unmount (fn [this])
 :component-did-catch (fn [this error info])
 :reagent-render (fn [args....])
 ;; Or alternatively:
 :render (fn [this])
 ;; Deprecated methods:
 :UNSAFE_component-will-receive-props (fn [this new-argv])
 :UNSAFE_component-will-update (fn [this new-argv new-state])
 :UNSAFE_component-will-mount (fn [this])}
```

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

Map keys should use `React.Component` method names (https://reactjs.org/docs/react-component.html),
and can be provided in snake-case or camelCase.

State can be initialized using constructor, which matches React.Component class,
or using getInitialState which matches old React createClass function and is
now implemented by Reagent for compatibility.

State can usually be anything, e.g. Cljs object. But if using getDerivedState
methods, the state has to be plain JS object as React implementation uses
Object.assign to merge partial state into the current state.

React built-in static methods or properties are automatically defined as statics.

create-compiler

(create-compiler opts)
Creates Compiler object with given `opts`,
this can be passed to `render`, `as-element` and other functions to control
how they turn the Reagent-style Hiccup into React components and elements.

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:

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

which is equivalent to

```cljs
[: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.,

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

```cljs
(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])`.

Note that a cursor is lazy: its value will not change until it is
used. This may be noticed with add-watch.

dispose!

(dispose! x)
Stop the result of track! from updating.

flush

(flush)
Render dirty components immediately.

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.

is-client

merge-props

(merge-props)(merge-props defaults)(merge-props defaults props)(merge-props defaults props & others)
Utility function that merges some maps, handling `:class` and `:style`.

The :class value is always normalized (using `class-names`) even if no
merging is done.

next-tick

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

f will be called just before components are rendered.

partial

(partial f & args)
Works just like clojure.core/partial, but the result can be compared with =

props

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

reactify-component

(reactify-component c)(reactify-component c compiler)
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

deprecated in 0.10.0

(render & _)

replace-state

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

rswap!

(rswap! a f & args)
Swaps the value of a to be `(apply f current-value-of-atom args)`.

rswap! works like swap!, except that recursive calls to rswap! on
the same atom are allowed – and it always returns nil.

set-default-compiler!

(set-default-compiler! compiler)
Globally sets the Compiler object used by `render`, `as-element` and other
calls by default, when no `compiler` parameter is provided.

Use `nil` value to restore the original default compiler.

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.

track

(track f & args)
Takes a function and optional arguments, and returns a derefable
containing the output of that function. If the function derefs
Reagent atoms (or track, etc), the value will be updated whenever
the atom changes.

In other words, `@(track foo bar)` will produce the same result
as `(foo bar)`, but foo will only be called again when the atoms it
depends on changes, and will only trigger updates of components when
its result changes.

track is lazy, i.e the function is only evaluated on deref.

track!

(track! f & args)
An eager version of track. The function passed is called
immediately, and continues to be called when needed, until stopped
with dispose!.

with-let

macro

(with-let bindings & body)
Bind variables as with let, except that when used in a component
the bindings are only evaluated once. Also takes an optional finally
clause at the end, that is executed when the component is
destroyed.

with-let

macro

(with-let bindings & body)
Bind variables as with let, except that when used in a component
the bindings are only evaluated once. Also takes an optional finally
clause at the end, that is executed when the component is
destroyed.

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:

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

Probably useful only for passing to child components.