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

*logger* cljs

*raf* clj/s

-next-props cljs

(-next-props next-props component)

-prev-props cljs

(-prev-props prev-props component)

add-root! clj/s

(add-root! reconciler root-class target)

(add-root! reconciler root-class target options)

Given a root component class and a target root DOM node, instantiate and render the root class using the reconciler's :state property. The reconciler will continue to observe changes to :state and keep the target node in sync. Note a reconciler may have only one root. If invoked on a reconciler with an existing root, the new root will replace the old one.

annotate-mutations clj/s

(annotate-mutations tx ident)

Given a query expression annotate all mutations by adding a :mutator -> ident entry to the metadata of each mutation expression in the query.

app-root clj/s

(app-root reconciler)

Return the application's root component.

app-state clj/s

(app-state reconciler)

Return the reconciler's application state atom. Useful when the reconciler was initialized via denormalized data.

ast->query clj/s

(ast->query query-ast)

children clj/s

(children component)

Returns the component's children.

class->any clj/s

(class->any x class)

Get any component from the indexer that matches the component class.

class-path clj/s

(class-path c)

Return the component class path associated with a component.

class-path->queries clj/s

(class-path->queries x y)

Given x (a reconciler or indexer) and y (a component or component class path), return the queries for that path.

collect-statics clj/s

(collect-statics dt)

component? clj/s

(component? x)

Returns true if the argument is an Om component.

computed clj/s

(computed props computed-map)

Add computed properties to props. Note will replace any pre-existing computed properties.

db->tree clj/s

(db->tree query data refs)

(db->tree query data refs map-ident)

Given a query, some data in the default database format, and the entire application state in the default database format, return the tree where all ident links have been replaced with their original node values.

default-extract-errors clj/s

(default-extract-errors reconciler res query)

default-merge clj/s

(default-merge reconciler state res query)

default-merge-ident clj/s

(default-merge-ident _ tree ref props)

default-merge-tree clj/s

(default-merge-tree a b)

default-migrate clj/s

(default-migrate app-state-pure query tempids)

(default-migrate app-state-pure query tempids id-key)

Given app-state-pure (the application state as an immutable value), a query, tempids (a hash map from tempid to stable id), and an optional id-key keyword, return a new application state value with the tempids replaced by the stable ids.

default-ui->props clj/s

(default-ui->props {:keys [parser pathopt] :as env} c)

defui clj/s≠ macro

clj

(defui name & forms)

cljs

(defui &form &env name & forms)

defui* clj/s

(defui* name form)

(defui* name forms env)

defui*-clj clj

(defui*-clj name forms)

depth clj/s

(depth component)

PRIVATE: Returns the render depth (a integer) of the component relative to the mount root.

dispatch clj/s

(dispatch _ key _)

Helper function for implementing :read and :mutate as multimethods. Use this as the dispatch-fn.

factory clj/s

(factory class)

(factory class
         {:keys [validator keyfn instrument?] :or {instrument? true} :as opts})

Create a factory constructor from a component class created with om.next/defui.

focus-query clj/s

(focus-query query path)

Given a query, focus it along the specified path.

Examples: (om.next/focus-query [:foo :bar :baz] [:foo]) => [:foo]

(om.next/focus-query [{:foo [:bar :baz]} :woz] [:foo :bar]) => [{:foo [:bar]}]

force clj/s

(force expr)

(force expr target)

Given a query expression return an equivalent query expression that can be spliced into a transaction that will force a read of that key from the specified remote target.

force-root-render! clj/s

(force-root-render! reconciler)

Force a re-render of the root. Not recommended for anything except recomputing :shared.

from-history clj/s

(from-history reconciler uuid)

Given a reconciler and UUID return the application state snapshost from history associated with the UUID. The size of the reconciler history may be configured by the :history option when constructing the reconciler.

full-query clj/s

(full-query component)

(full-query component query)

Returns the absolute query for a given component, not relative like om.next/get-query.

gather-sends clj/s

(gather-sends {:keys [parser] :as env} q remotes)

Given an environment, a query and a set of remotes return a hash map of remotes mapped to the query specific to that remote.

get-computed clj/s

(get-computed x)

(get-computed x k-or-ks)

Return the computed properties on a component or its props.

get-ident clj/s

(get-ident x)

Given a mounted component with assigned props, return the ident for the component.

get-indexer clj/s

(get-indexer reconciler)

PRIVATE: Get the indexer associated with the reconciler.

get-params clj/s

(get-params component)

Return the query params for a component.

get-query clj/s

(get-query x)

Return a IQuery/IParams instance bound query. Works for component classes and component instances. See also om.next/full-query.

get-reconciler clj/s

(get-reconciler c)

get-rendered-state clj/s

(get-rendered-state component)

(get-rendered-state component k-or-ks)

Get the rendered state of component. om.next/get-state always returns the up-to-date state.

get-state clj/s

(get-state component)

(get-state component k-or-ks)

Get a component's local state. May provide a single key or a sequential collection of keys for indexed access into the component's local state.

get-unbound-query clj/s

(get-unbound-query component)

Return the unbound query for a component.

Ident clj/s≠ protocol

ident clj/s

(ident this props)

Return the ident for this component

ILocalState clj/s≠ protocol

-get-rendered-state clj/s

(-get-rendered-state this)

Get the component's rendered local state

-get-state clj/s

(-get-state this)

Get the component's local state

-merge-pending-state! clj/s

(-merge-pending-state! this)

Get the component's pending local state

-set-state! clj/s

(-set-state! this new-state)

Set the component's local state

indexer clj/s

(indexer)

(indexer extfs)

Given a function (Component -> Ref), return an indexer.

Indexer cljs

instrument clj/s

(instrument component)

invariant clj/s macro

(invariant condition message)

invariant* clj/s

(invariant* condition message env)

IQuery clj/s≠ protocol

query clj/s

(query this)

Return the component's unbound query

iquery? clj/s

(iquery? x)

IQueryParams clj/s≠ protocol

params clj/s

(params this)

Return the query parameters

ITxIntercept clj/s≠ protocol

tx-intercept clj/s

(tx-intercept c tx)

An optional protocol that component may implement to intercept child transactions.

lifecycle-sigs clj/s

merge! clj/s

(merge! reconciler delta)

(merge! reconciler delta query)

(merge! reconciler delta query remote)

Merge a state delta into the application state. Affected components managed by the reconciler will re-render.

mounted? clj/s

(mounted? x)

Returns true if the component is mounted.

nil-or-map? clj/s

(nil-or-map? x)

parser clj/s

(parser {:keys [read mutate] :as opts})

Create a parser. The argument is a map of two keys, :read and :mutate. Both functions should have the signature (Env -> Key -> Params -> ParseResult).

process-roots clj/s

(process-roots query)

props clj/s≠

(props component)

cljs

Return a components props.

query->ast clj/s

(query->ast query-expr)

Given a query expression convert it into an AST.

react-key clj/s

(react-key component)

Returns the components React key.

react-ref clj/s

(react-ref component name)

Returns the component associated with a component's React ref.

react-set-state! clj/s

(react-set-state! component new-state)

(react-set-state! component new-state cb)

react-type clj/s≠

clj

(react-type component)

cljs

(react-type x)

Returns the component type, regardless of whether the component has been mounted

reader clj/s

(reader)

(reader opts)

Create a Om Next transit reader. This reader can handler the tempid type. Can pass transit reader customization opts map.

Reconciler cljs

reconciler clj/s≠

clj

(reconciler
  {:keys [state shared shared-fn parser indexer ui->props normalize send
          merge-sends remotes merge merge-tree merge-ident prune-tree optimize
          history root-render root-unmount pathopt migrate id-key instrument
          tx-listen easy-reads]
   :or {root-render (fn [c target] c)
        prune-tree default-extract-errors
        pathopt false
        merge-sends (fn* [p1__3241# p2__3242#]
                         (merge-with into p1__3241# p2__3242#))
        merge-ident default-merge-ident
        remotes [:remote]
        migrate default-migrate
        easy-reads true
        history 100
        merge default-merge
        ui->props default-ui->props
        indexer om.next/indexer
        root-unmount (fn [x])
        merge-tree default-merge-tree
        optimize (fn [cs] (sort-by depth cs))}
   :as config})

cljs

(reconciler
  {:keys [state shared shared-fn parser indexer ui->props normalize send
          merge-sends remotes merge merge-tree merge-ident prune-tree optimize
          history root-render root-unmount pathopt migrate id-key instrument
          tx-listen easy-reads]
   :or {root-render (fn* [p1__4007# p2__4008#]
                         (js/ReactDOM.render p1__4007# p2__4008#))
        prune-tree default-extract-errors
        pathopt false
        merge-sends (fn* [p1__4005# p2__4006#]
                         (merge-with into p1__4005# p2__4006#))
        merge-ident default-merge-ident
        remotes [:remote]
        migrate default-migrate
        easy-reads true
        history 100
        merge default-merge
        ui->props default-ui->props
        indexer om.next/indexer
        root-unmount (fn* [p1__4009#]
                          (js/ReactDOM.unmountComponentAtNode p1__4009#))
        merge-tree default-merge-tree
        optimize (fn [cs] (sort-by depth cs))}
   :as config})

Construct a reconciler from a configuration map.

Required parameters: :state - the application state. If IAtom value is not supplied the data will be normalized into the default database format using the root query. This can be disabled by explicitly setting the optional :normalize parameter to false. :parser - the parser to be used

Optional parameters: :shared - a map of global shared properties for the component tree. :shared-fn - a function to compute global shared properties from the root props. the result is merged with :shared. :send - required only if the parser will return a non-empty value when run against the supplied :remotes. send is a function of two arguments, the map of remote expressions keyed by remote target and a callback which should be invoked with the result from each remote target. Note this means the callback can be invoked multiple times to support parallel fetching and incremental loading if desired. The callback should take the response as the first argument and the the query that was sent as the second argument. :normalize - whether the state should be normalized. If true it is assumed all novelty introduced into the system will also need normalization. :remotes - a vector of keywords representing remote services which can evaluate query expressions. Defaults to [:remote] :root-render - the root render function. Defaults to ReactDOM.render :root-unmount - the root unmount function. Defaults to ReactDOM.unmountComponentAtNode :logger - supply a goog.log compatible logger :tx-listen - a function of 2 arguments that will listen to transactions. The first argument is the parser's env map also containing the old and new state. The second argument is a map containing the transaction, its result and the remote sends that the transaction originated.

reconciler? clj/s

(reconciler? x)

Returns true if x is a reconciler.

reduce-query-depth clj/s

(reduce-query-depth q k)

Changes a join on key k with depth limit from [:a {:k n}] to [:a {:k (dec n)}]

ref->any clj/s

(ref->any x ref)

Get any component from the indexer that matches the ref.

ref->components clj/s

(ref->components x ref)

Return all components for a given ref.

remove-root! clj/s

(remove-root! reconciler target)

Remove a root target (a DOM element) from a reconciler. The reconciler will no longer attempt to reconcile application state with the specified root.

reshape clj/s

(reshape dt {:keys [reshape defaults]})

reshape-map clj/s

reshape-map-clj clj

rewrite clj/s

(rewrite rewrite-map result)

schedule-render! clj/s≠

clj

cljs

(schedule-render! reconciler)

schedule-sends! clj/s

(schedule-sends! reconciler)

set-query! clj/s

(set-query! x params&query)

(set-query! x {:keys [params query]} reads)

Change the query of a component. Takes a map containing :params and/or :query. :params should be a map of new bindings and :query should be a query expression. Will schedule a re-render as well as remote re-sends if necessary.

set-state! clj/s≠

(set-state! component new-state)

cljs

Set the component local state of the component. Analogous to React's setState.

shared clj/s

(shared component)

(shared component k-or-ks)

Return the global shared properties of the Om Next root. See :shared and :shared-fn reconciler options.

should-update? cljs

(should-update? c next-props)

(should-update? c next-props next-state)

some-iquery? clj/s

(some-iquery? c)

subquery clj/s

(subquery x subquery-ref subquery-class)

Given a class or mounted component x and a ref to an instantiated component or class that defines a subquery, pick the most specific subquery. If the component is mounted subquery-ref will be used, subquery-class otherwise.

tag clj/s

(tag x class)

tempid clj/s

(tempid)

(tempid id)

Return a temporary id.

tempid? clj/s

(tempid? x)

Return true if x is a tempid, false otherwise

transact! clj/s

(transact! x tx)

(transact! r ref tx)

Given a reconciler or component run a transaction. tx is a parse expression that should include mutations followed by any necessary read. The reads will be used to trigger component re-rendering.

Example:

(om/transact! widget '[(do/this!) (do/that!) :read/this :read/that])

transact* clj/s

(transact* r c ref tx)

transform-reads clj/s

(transform-reads r tx)

Given r (a reconciler) and a query expression including a mutation and any simple reads, return the equivalent query expression where the simple reads have been replaced by the full query for each component that cares about the specified read.

tree->db clj/s

(tree->db x data)

(tree->db x data merge-idents)

Given a Om component class or instance and a tree of data, use the component's query to transform the tree into the default database format. All nodes that can be mapped via Ident implementations wil be replaced with ident links. The original node data will be moved into tables indexed by ident. If merge-idents option is true, will return these tables in the result instead of as metadata.

ui clj/s≠ macro

clj

(ui & forms)

cljs

(ui &form &env & forms)

update-query! clj/s

(update-query! component f)

(update-query! component f arg0)

(update-query! component f arg0 arg1)

(update-query! component f arg0 arg1 arg2)

(update-query! component f arg0 arg1 arg2 arg3 & arg-rest)

Update a component's query and query parameters with a function.

update-state! clj/s

(update-state! component f)

(update-state! component f arg0)

(update-state! component f arg0 arg1)

(update-state! component f arg0 arg1 arg2)

(update-state! component f arg0 arg1 arg2 arg3)

(update-state! component f arg0 arg1 arg2 arg3 & arg-rest)

Update a component's local state. Similar to Clojure(Script)'s swap!

validate-sig clj/s

(validate-sig [name sig :as method])

writer clj/s

(writer)

(writer opts)

Create a Om Next transit writer. This writer can handler the tempid type. Can pass transit writer customization opts map.