om.core — org.omcljs/om 1.0.0-beta4

_refs cljs

adapt cljs

(adapt x other)

add-ref-to-component! cljs

(add-ref-to-component! c ref)

build cljs

(build f x)

(build f x m)

Builds an Om component. Takes an IRender/IRenderState instance returning function f, a value, and an optional third argument which may be a map of build specifications.

f - is a function of 2 or 3 arguments. The first argument can be any value and the second argument will be the owning pure node. If a map of options m is passed in this will be the third argument. f must return at a minimum an IRender or IRenderState instance, this instance may implement other React life cycle protocols.

x - any value

m - a map the following keys are allowed:

:key - a keyword that should be used to look up the key used by React itself when rendering sequential things. :react-key - an explicit react key :fn - a function to apply to the data before invoking f. :init-state - a map of initial state to pass to the component. :state - a map of state to pass to the component, will be merged in. :opts - a map of values. Can be used to pass side information down the render tree. :descriptor - a JS object of React methods, will be used to construct a React class per Om component function encountered. defaults to pure-descriptor.

Example:

(build list-of-gadgets x {:init-state {:event-chan ... :narble ...}})

build* cljs

(build* f cursor)

(build* f cursor m)

build-all cljs

(build-all f xs)

(build-all f xs m)

Build a sequence of components. f is the component constructor function, xs a sequence of values, and m a map of options the same as provided to om.core/build.

commit! cljs

(commit! cursor korks f)

EXPERIMENTAL: Like transact! but does not schedule a re-render or create a transact event.

component clj/s macro

(component & body)

Sugar over reify for quickly putting together components that only need to implement om.core/IRender and don't need access to the owner argument.

component? cljs

(component? x)

cursor? cljs

(cursor? x)

detach-root cljs

(detach-root target)

Given a DOM target remove its render loop if one exists.

get-descriptor cljs

(get-descriptor f)

(get-descriptor f descriptor)

get-gstate cljs

(get-gstate owner)

get-node cljs

(get-node owner)

(get-node owner name)

A helper function to get at React DOM refs. Given a owning pure node extract the DOM ref specified by name.

get-props cljs

(get-props x)

(get-props x korks)

Given an owning Pure node return the Om props. Analogous to React component props.

get-ref cljs

(get-ref owner name)

A helper function to get at React refs. Given an owning pure node extract the ref specified by name.

get-render-state cljs

(get-render-state owner)

(get-render-state owner korks)

Takes a pure owning component and an optional key or sequential list of keys and returns a property in the component local state if it exists. Always returns the rendered state, not the pending state.

get-shared cljs

(get-shared owner)

(get-shared owner korks)

Takes an owner and returns a map of global shared values for a render loop. An optional key or sequence of keys may be given to extract a specific value.

get-state cljs

(get-state owner)

(get-state owner korks)

Returns the component local state of an owning component. owner is the component. An optional key or sequence of keys may be given to extract a specific value. Always returns pending state.

getf cljs

(getf f cursor)

(getf f cursor opts)

IAdapt cljs protocol

-adapt cljs

(-adapt this other)

ICheckState cljs protocol

ICursor cljs protocol

-state cljs

(-state cursor)

-path cljs

(-path cursor)

ICursorDerive cljs protocol

-derive cljs

(-derive cursor derived state path)

id cljs

(id owner)

IDidMount cljs protocol

did-mount cljs

(did-mount this)

IDidUpdate cljs protocol

did-update cljs

(did-update this prev-props prev-state)

IDisplayName cljs protocol

display-name cljs

(display-name this)

IGetRenderState cljs protocol

-get-render-state cljs

(-get-render-state this)

(-get-render-state this ks)

IGetState cljs protocol

-get-state cljs

(-get-state this)

(-get-state this ks)

IInitState cljs protocol

init-state cljs

(init-state this)

IndexedCursor cljs

INotify cljs protocol

-unlisten! cljs

(-unlisten! x key)

-listen! cljs

(-listen! x key tx-listen)

-notify! cljs

(-notify! x tx-data root-cursor)

IOmRef cljs protocol

-refresh-deps! cljs

(-refresh-deps! this)

-add-dep! cljs

(-add-dep! this c)

-get-deps cljs

(-get-deps this)

-remove-dep! cljs

(-remove-dep! this c)

IOmSwap cljs protocol

-om-swap! cljs

(-om-swap! this cursor korks f tag)

IRender cljs protocol

render cljs

(render this)

IRenderProps cljs protocol

render-props cljs

(render-props this props state)

IRenderQueue cljs protocol

-get-queue cljs

(-get-queue this)

-queue-render! cljs

(-queue-render! this c)

-empty-queue! cljs

(-empty-queue! this)

IRenderState cljs protocol

render-state cljs

(render-state this state)

IRootKey cljs protocol

-root-key cljs

(-root-key cursor)

IRootProperties cljs protocol

-set-property! cljs

(-set-property! this id p val)

-remove-property! cljs

(-remove-property! this id p)

-get-property cljs

(-get-property this id p)

-remove-properties! cljs

(-remove-properties! this id)

ISetState cljs protocol

-set-state! cljs

(-set-state! this val render)

(-set-state! this ks val render)

IShouldUpdate cljs protocol

should-update cljs

(should-update this next-props next-state)

IToCursor cljs protocol

-to-cursor cljs

(-to-cursor value state)

(-to-cursor value state path)

ITransact cljs protocol

-transact! cljs

(-transact! cursor korks f tag)

IValue cljs protocol

-value cljs

(-value x)

IWillMount cljs protocol

will-mount cljs

(will-mount this)

IWillReceiveProps cljs protocol

will-receive-props cljs

(will-receive-props this next-props)

IWillUnmount cljs protocol

will-unmount cljs

(will-unmount this)

IWillUpdate cljs protocol

will-update cljs

(will-update this next-props next-state)

MapCursor cljs

mounted? cljs

(mounted? owner)

Return true if the backing React component is mounted into the DOM.

no-local-descriptor cljs

(no-local-descriptor methods)

no-local-merge-pending-state cljs

(no-local-merge-pending-state owner)

no-local-state-methods cljs

notify* cljs

(notify* cursor tx-data)

observe cljs

(observe c ref)

Given a component and a reference cursor have the component observe the reference cursor for any data changes.

path cljs

(path cursor)

pure-descriptor cljs

pure-methods cljs

react-id cljs

(react-id x)

ref-changed? cljs

(ref-changed? ref)

ref-cursor cljs

(ref-cursor cursor)

Given a cursor return a reference cursor that inherits all of the properties and methods of the cursor. Reference cursors may be observed via om.core/observe.

ref-cursor? cljs

(ref-cursor? x)

ref-sub-cursor cljs

(ref-sub-cursor x parent)

refresh! cljs

(refresh! owner)

Utility to re-render an owner.

refresh-props! cljs

remove-ref-from-component! cljs

(remove-ref-from-component! c ref)

render-all cljs

(render-all)

(render-all state)

Force a render of all roots. Usage of this function is almost never recommended.

root cljs

(root f
      value
      {:keys [target tx-listen path instrument descriptor adapt raf]
       :as options})

Take a component constructor function f, value an immutable tree of associative data structures optionally an wrapped in an IAtom instance, and a map of options and installs an Om/React render loop.

f must return an instance that at a minimum implements IRender or IRenderState (it may implement other React life cycle protocols). f must take at least two arguments, the root cursor and the owning pure node. A cursor is just the original data wrapped in an ICursor instance which maintains path information. Only one root render loop allowed per target element. om.core/root is idempotent, if called again on the same target element the previous render loop will be replaced.

Options may also include any key allowed by om.core/build to customize f. In addition om.core/root supports the following special options:

:target - (required) a DOM element. :shared - data to be shared by all components, see om.core/get-shared :tx-listen - a function that will listen in in transactions, should take 2 arguments - the first a map containing the path, old and new state at path, old and new global state, and transaction tag if provided. :instrument - a function of three arguments that if provided will intercept all calls to om.core/build. This function should correspond to the three arity version of om.core/build. :adapt - a function to adapt the root cursor :raf - override requestAnimationFrame based rendering. If false setTimeout will be use. If given a function will be invoked instead.

Example:

(root (fn [data owner] ...) {:message :hello} {:target js/document.body})

root-cursor cljs

(root-cursor atom)

Given an application state atom return a root cursor for it.

set-state! cljs

(set-state! owner v)

(set-state! owner korks v)

Takes a pure owning component, a sequential list of keys and value and sets the state of the component. Conceptually analagous to React setState. Will schedule an Om re-render.

set-state-nr! cljs

(set-state-nr! owner v)

(set-state-nr! owner korks v)

EXPERIMENTAL: Same as set-state! but does not trigger re-render.

specify-state-methods! cljs

(specify-state-methods! obj)

state cljs

(state cursor)

tag-root-key cljs

(tag-root-key cursor root-key)

transact! cljs

(transact! cursor f)

(transact! cursor korks f)

(transact! cursor korks f tag)

Given a tag, a cursor, an optional list of keys ks, mutate the tree at the path specified by the cursor + the optional keys by applying f to the specified value in the tree. An Om re-render will be triggered.

transact* cljs

(transact* state cursor korks f tag)

transactable? cljs

(transactable? x)

unobserve cljs

(unobserve c ref)

update! cljs

(update! cursor v)

(update! cursor korks v)

(update! cursor korks v tag)

Like transact! but no function provided, instead a replacement value is given.

update-refs cljs

(update-refs c)

update-state! cljs

(update-state! owner f)

(update-state! owner korks f)

Takes a pure owning component, a sequential list of keys and a function to transition the state of the component. Conceptually analagous to React setState. Will schedule an Om re-render.

update-state-nr! cljs

(update-state-nr! owner f)

(update-state-nr! owner korks f)

EXPERIMENTAL: Same as update-state! but does not trigger re-render.

valid? cljs

(valid? x)

value cljs

(value cursor)