fulcro.client.primitives — fulcrologic/fulcro 2.8.13

*blindly-render* clj/s

*depth* clj/s

*instrument* clj/s

*parent* clj/s

*raf* clj/s

*reconciler* clj/s

*shared* clj/s

-children-by-prop clj

(-children-by-prop query)

PRIVATE.

-legal-keys clj

(-legal-keys query)

PRIVATE. Find the legal keys in a query. NOTE: This is at compile time, so the get-query calls are still embedded (thus cannot use the AST)

-merge-novelty clj/s

(-merge-novelty reconciler state-map result-tree query)

(-merge-novelty reconciler state-map result-tree query tempids)

PRIVATE. DO NOT USE.

-optimal-render clj/s

(-optimal-render reconciler refresh-queue render-root)

PRIVATE.

Run an optimal render of the given refresh-queue (a list of idents and data query keywords). This function attempts to refresh the minimum number of components according to the UI depth and state. If it cannot do targeted updates then it will call render-root to render the entire UI. Other optimizations may apply in render-root.

-preprocess-merge clj/s

(-preprocess-merge state-atom component object-data)

PRIVATE.

Does the steps necessary to honor the data merge technique defined by Fulcro with respect to data overwrites in the app database.

-queue-render! cljs

(-queue-render! f)

PRIVATE.

-reconciler-normalize-initial-state clj/s

(-reconciler-normalize-initial-state {:keys [config state]} root-class)

PRIVATE

-register-component! clj/s

(-register-component! k component-class)

Add a component to Fulcro's component registry. This is used by defsc and defui to ensure that all Fulcro classes that have been compiled (transitively required) will be accessible for lookup by name. Not meant for public use, unless you're creating your own component macro that doesn't directly leverage defsc/defui.

-to-env clj/s

(-to-env x)

PRIVATE: do not use.

add-basis-time clj/s

(add-basis-time props time)

(add-basis-time q props time)

Recursively add the given basis time to all of the maps in the props. This is part of the UI refresh optimization algorithm. Children that refresh in isolation could be mis-drawn if a parent subsequently does a re-render without a query (e.g. local state change). The basis times allow us to detect and avoid that.

add-basis-time* clj/s

(add-basis-time* {:keys [children]} props time)

add-pending-request clj/s

(add-pending-request reconciler remote request)

Adds request to a queue in the reconciler. This queue is not used for internal processing, only because the contents of core.async channels are opaque.

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.

any->reconciler clj/s

(any->reconciler x)

Attempt to coerce x to a reconciler. Legal inputs are a fulcro application, reconciler, a mounted component, a map with a :reconciler key, or an atom holding any of the above.

app-root clj/s

(app-root reconcilerish)

Return the application's root component. Argument can be anything that any->reconciler accepts.

app-state clj/s

(app-state x)

Return the state atom.

x can be anything that any->reconciler works with.

as-leaf clj/s

(as-leaf data)

Returns data with meta-data marking it as a leaf in the result.

ast->query clj/s

(ast->query query-ast)

build-css clj

(build-css env
           thissym
           {css-method :method css-template :template}
           {include-method :method include-template :template})

build-prop->class-index! clj/s

(build-prop->class-index! prop->classes query)

Build an index from property to class using the (annotated) query.

children clj/s

(children component)

Returns the component's children.

class->all clj/s

(class->all x class)

Get any component from the indexer that matches the component class. x can be anything that any->reconciler works with.

class->any clj/s

(class->any x class)

Get any component from the indexer that matches the component class. x can be anything that any->reconciler will accept.

classname->class clj/s

(classname->class classname)

Look up the given component in Fulcro's global component registry. Will only be able to find components that have been (transitively) required by your application.

classname can be a fully-qualified keyword or symbol.

collect-statics clj/s

(collect-statics dt)

Collect the static declarations from the defui.

component->state-map clj/s

(component->state-map component)

Get the normalized database state as a map. Requires a mounted component instance.

component-class? clj/s

(component-class? x)

Returns true if the given x is a defsc or defui component class definition.

component-merge-query clj/s

(component-merge-query component object-data)

Calculates the query that can be used to pull (or merge) a component with an ident to/from a normalized app database. Requires a tree of data that represents the instance of the component in question (e.g. ident will work on it)

component-name clj/s

(component-name class)

Returns a string version of the given react component's name.

component-pre-merge clj/s

(component-pre-merge class query state data)

component? clj/s

(component? x)

Returns true if the argument is a component. A component is defined as a mounted React-based javascript component. This function returns false for component classes, and also returns false for the output of a Fulcro component factory.

compressible-transact! clj/s

(compressible-transact! comp-or-reconciler tx)

Identical to transact!, but marks the history edge as compressible. This means that if more than one adjacent history transition edge is compressible, only the more recent of the sequence of them is kept. This is useful for things like form input fields, where storing every keystoke in history is undesirable.

NOTE: history events that trigger remote interactions are not compressible, since they may be needed for automatic network error recovery handling..

computed clj/s

(computed props computed-map)

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

computed-factory clj/s

(computed-factory class)

(computed-factory class options)

Similar to factory, but returns a function with the signature [props computed & children] instead of default [props & children]. This makes easier to send computed.

computed-initial-state? clj/s

(computed-initial-state? s)

Returns true if the given initial state was computed from a call to get-initial-state.

create-element cljs

(create-element class props children)

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.

dedup-components-by-path clj/s

(dedup-components-by-path components)

Remove components from the given list by removing those whose paths are encompassed by others. In other words, remove components from the list when there is a parent of that component also in the list.

deep-merge clj/s

(deep-merge & xs)

default-component-prototype cljs

defsc clj/s macro

(defsc & args)

Define a stateful component. This macro emits a React UI class with a query, optional ident (if :ident is specified in options), optional initial state, optional css, lifecycle methods, and a render method. It can also cause the class to implement additional protocols that you specify. Destructuring is supported in the argument list.

The template (data-only) versions do not have any arguments in scope The lambda versions have arguments in scope that make sense for those lambdas, as listed below:

(defsc Component [this {:keys [db/id x] :as props} {:keys [onSelect] :as computed} css-classmap]
  {
   ;; stateful component options
   ;; query template is literal. Use the lambda if you have ident-joins or unions.
   :query [:db/id :x] ; OR (fn [] [:db/id :x]) ; this in scope
   ;; ident template is table name and ID property name
   :ident [:table/by-id :id] ; OR (fn [] [:table/by-id id]) ; this and props in scope
   ;; initial-state template is magic..see dev guide. Lambda version is normal.
   :initial-state {:x :param/x} ; OR (fn [params] {:x (:x params)}) ; this in scope
   ;; pre-merge, use a lamba to modify new merged data with component needs
   :pre-merge (fn [tree] (merge {:ui/default-value :start} tree))
   :css [] ; garden css rules
   :css-include [] ; list of components that have CSS to compose towards root.

   ; React Lifecycle Methods (this in scope)
   :initLocalState            (fn [] ...) ; CAN BE used to call things as you might in a constructor. Return value is initial state.
   :shouldComponentUpdate     (fn [next-props next-state] ...)

   :componentDidUpdate        (fn [prev-props prev-state snapshot] ...) ; snapshot is optional, and is 16+. Is context for 15
   :componentDidMount         (fn [] ...)
   :componentWillUnmount      (fn [] ...)

   ;; DEPRECATED IN REACT 16 (to be removed in 17):
   :componentWillReceiveProps        (fn [next-props] ...)
   :componentWillUpdate              (fn [next-props next-state] ...)
   :componentWillMount               (fn [] ...)

   ;; Replacements for deprecated methods in React 16.3+
   :UNSAFE_componentWillReceiveProps (fn [next-props] ...)
   :UNSAFE_componentWillUpdate       (fn [next-props next-state] ...)
   :UNSAFE_componentWillMount        (fn [] ...)

   ;; ADDED for React 16:
   :componentDidCatch         (fn [error info] ...)
   :getSnapshotBeforeUpdate   (fn [prevProps prevState] ...)
   :getDerivedStateFromProps  (fn [props state] ...)

   ;; ADDED for React 16.6:
   :getDerivedStateFromError  (fn [error] ...)  **NOTE**: OVERWRITES entire state. This differs slightly from React.

   NOTE: shouldComponentUpdate should generally not be overridden other than to force it false so
   that other libraries can control the sub-dom. If you do want to implement it, then old props can
   be obtained from (prim/props this), and old state via (gobj/get (. this -state) "fulcro$state").

   ; Custom literal protocols (Object ok, too, to add arbitrary methods. Nothing automatically in scope.)
   :protocols [YourProtocol
               (method [this] ...)]} ; nothing is automatically in scope
   ; BODY forms. May be omitted IFF there is an options map, in order to generate a component that is used only for queries/normalization.
   (dom/div #js {:onClick onSelect} x))

See the Developer's Guide at book.fulcrologic.com for more details.

defsc* clj

(defsc* env args)

defui clj/s macro

(defui name & forms)

defui* clj

(defui* name form)

(defui* name forms env)

defui*-clj clj

(defui*-clj name forms)

denormalize-query clj/s

(denormalize-query state-map ID)

Takes a state map that may contain normalized queries and a query ID. Returns the stored query or nil.

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.

extract-static-methods clj

(extract-static-methods protocols)

factory clj/s≠

(factory class)

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

clj

Create a factory constructor from a component class created with fulcro.client.primitives/defui.

cljs

Create a factory constructor from a component class created with defui.

fallback-tx clj/s

(fallback-tx tx resp)

focus-query clj/s

(focus-query query path)

Given a query, focus it along the specified path.

Examples: (focus-query [:foo :bar :baz] [:foo]) => [:foo]

(fulcro.client.primitives/focus-query [{:foo [:bar :baz]} :woz] [:foo :bar]) => [{:foo [:bar]}]

focus-subquery clj/s

(focus-subquery query sub-query)

Given a query, focus it along the specified query expression.

Examples: (focus-query [:foo :bar :baz] [:foo]) => [:foo]

(fulcro.client.primitives/focus-query [{:foo [:bar :baz]} :woz] [{:foo [:bar]} :woz]) => [{:foo [:bar]} :woz]

force-root-render! clj/s

(force-root-render! reconcilerish)

Force a re-render of the root. Runs a root query, disables shouldComponentUpdate, and renders the root component. This effectively forces React to do a full VDOM diff. Useful for things like changing locales where there are no real data changes, but the UI still needs to refresh. recomputing :shared.

Argument can be anything that any->reconciler accepts.

force-update cljs

(force-update c)

(force-update c cb)

An exception-protected React .forceUpdate

fragment clj/s≠

(fragment & args)

cljs

Wraps children in a React.Fragment. Props are optional, like normal DOM elements.

fulcro-ui->props clj/s

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

Finds props for a given component. Returns ::no-ident if the component has no ident (which prevents localized update). This eliminates the need for path data.

gather-keys clj/s

(gather-keys query)

Gather the keys that would be considered part of the refresh set for the given query.

E.g. [:a {:j [:b]} {:u {:x [:l] :y [:k]}}] ==> #{:a :j :u}

gather-sends clj/s

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

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-basis-time clj/s

(get-basis-time props)

Returns the basis time from the given props, or ::unset if not available.

get-computed clj/s

(get-computed x)

(get-computed x k-or-ks)

Return the computed properties on a component or its props.

get-current-time clj/s

(get-current-time reconciler)

get the current basis time from the reconciler. Used instead of calling the protocol method basis-t to facilitate testing.

get-history clj/s

(get-history reconciler)

pass-through function for getting history, that enables testing (cannot mock protocols easily)

get-ident clj/s

(get-ident x)

(get-ident class props)

Get the ident for a mounted component OR using a component class.

That arity-2 will return the ident using the supplied props map.

The single-arity version should only be used with a mounted component (e.g. this from render), and will derive the props that were sent to it most recently.

get-indexer clj/s

(get-indexer reconciler)

PRIVATE: Get the indexer associated with the reconciler.

get-initial-state clj/s

(get-initial-state class params)

Get the initial state of a component. Needed because calling the protocol method from a defui component in clj will not work as expected.

get-network-activity clj/s

(get-network-activity reconciler)

get-query clj/s

(get-query class-or-factory)

(get-query class-or-factory state-map)

Get the query for the given class or factory. If called without a state map, then you'll get the declared static query of the class. If a state map is supplied, then the dynamically set queries in that state will result in the current dynamically-set query according to that state.

get-query-by-id clj/s

(get-query-by-id state-map class queryid)

get-reconciler clj/s

(get-reconciler c)

Pull a reconciler from a mounted component. See also any->reconciler.

get-rendered-state clj/s

(get-rendered-state component)

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

Get the rendered state of component. fulcro.client.primitives/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-tempids clj/s

(get-tempids m)

has-ident? clj/s

(has-ident? component)

has-initial-app-state? clj/s

(has-initial-app-state? component)

has-pre-merge? clj/s

(has-pre-merge? component)

has-query? clj/s

(has-query? component)

Ident clj/s≠ protocol

ident clj/s

(ident this props)

Return the ident for this component

Indexer cljs

init-local-state clj

(init-local-state component)

InitialAppState clj/s≠ protocol

initial-state clj/s

(initial-state clz params)

Get the initial state to be used for this component in app state. You are responsible for composing these together.

instrument clj/s

(instrument component)

integrate-ident clj/s

(integrate-ident state ident & named-parameters)

DEPRECATED: Use fulcro.client.mutations/integrate-ident* in your mutations instead.

integrate-ident! clj/s

(integrate-ident! state ident & named-parameters)

DEPRECATED: Use fulcro.client.mutations/integrate-ident* in your mutations instead.

IPreMerge clj/s≠ protocol

pre-merge* clj/s

(pre-merge* this data)

Modify data before merging.

IQuery clj/s≠ protocol

query clj/s

(query this)

Return the component's unbound static query

is-factory? clj/s

(is-factory? class-or-factory)

is-link? clj

(is-link? query-element)

Returns true if the given query element is a link query like [:x '_].

leaf? clj/s

(leaf? data)

Returns true iff the given data is marked as a leaf in the result (according to the query). Requires pre-marking.

lifecycle-sigs clj

link-element clj/s

(link-element element)

link-query clj/s

(link-query query)

Find all of the elements (only at the top level) of the given query and replace them with their query ID

make-state-map clj/s

(make-state-map initial-state children-by-query-key params)

Build a component's initial state using the defsc initial-state-data from options, the children from options, and the params from the invocation of get-initial-state.

mark-missing clj/s

(mark-missing result query)

Recursively walk the query and response marking anything that was asked for in the query but is not in the response as missing. The merge process (which happens later in the plumbing) looks for these markers as indicators to remove any existing data in the database (which has provably disappeared).

The naive approach to data merging (even recursive) would fail to remove such data.

Returns the result with missing markers in place (which are then used/removed in a later stage).

merge! clj/s

(merge! reconciler data-tree)

(merge! reconciler data-tree query)

(merge! reconciler data-tree query remote)

Merge an arbitrary data-tree that conforms to the shape of the given query.

query - A query, derived from defui components, that can be used to normalized a tree of data. data-tree - A tree of data that matches the nested shape of query remote - No longer used. May be passed, but is ignored.

merge* clj/s

(merge* reconciler state res query)

Internal implementation of merge. Given a reconciler, state (map), result, and query returns a map of the:

:keys to refresh :next state and ::tempids that need to be migrated

merge-alternate-union-elements clj/s

(merge-alternate-union-elements state-map root-component)

Just like merge-alternate-union-elements!, but usable from within mutations and on server-side rendering. Ensures that when a component has initial state it will end up in the state map, even if it isn't currently in the initial state of the union component (which can only point to one at a time).

merge-alternate-union-elements! clj/s

(merge-alternate-union-elements! app root-component)

Walks the query and initial state of root-component and merges the alternate sides of unions with initial state into the application state database. See also merge-alternate-union-elements, which can be used on a state map and is handy for server-side rendering. This function side-effects on your app, and returns nothing.

merge-alternate-unions clj/s

(merge-alternate-unions merge-fn root-component)

Walks the given query and calls (merge-fn parent-union-component union-child-initial-state) for each non-default element of a union that has initial app state. You probably want to use merge-alternate-union-elements[!] on a state map or app.

merge-component clj/s

(merge-component state-map component component-data & named-parameters)

Given a state map of the application database, a component, and a tree of component-data: normalizes the tree of data and merges the component table entries into the state, returning a new state map. Since there is not an implied root, the component itself won't be linked into your graph (though it will remain correctly linked for its own consistency). Therefore, this function is just for dropping normalized things into tables when they themselves have a recursive nature. This function is useful when you want to create a new component instance and put it in the database, but the component instance has recursive normalized state. This is a basically a thin wrapper around prim/tree->db.

See also integrate-ident, integrate-ident!, and merge-component!

merge-component! clj/s

(merge-component! reconciler component object-data & named-parameters)

Normalize and merge a (sub)tree of application state into the application using a known UI component's query and ident.

This utility function obtains the ident of the incoming object-data using the UI component's ident function. Once obtained, it uses the component's query and ident to normalize the data and place the resulting objects in the correct tables. It is also quite common to want those new objects to be linked into lists in other spot in app state, so this function supports optional named parameters for doing this. These named parameters can be repeated as many times as you like in order to place the ident of the new object into other data structures of app state.

This function honors the data merge story for Fulcro: attributes that are queried for but do not appear in the data will be removed from the application. This function also uses the initial state for the component as a base for merge if there was no state for the object already in the database.

This function will also trigger re-renders of components that directly render object merged, as well as any components into which you integrate that data via the named-parameters.

This function is primarily meant to be used from things like server push and setTimeout/setInterval, where you're outside of the normal mutation story. Do not use this function within abstract mutations.

• reconciler: A reconciler
• component: The class of the component that corresponsds to the data. Must have an ident.
• object-data: A map (tree) of data to merge. Will be normalized for you.
• named-parameter: Post-processing ident integration steps. see integrate-ident!

Any keywords that appear in ident integration steps will be added to the re-render queue.

See also fulcro.client.primitives/merge!.

merge-handler clj/s

(merge-handler mutation-merge target source)

Handle merging incoming data, but be sure to sweep it of values that are marked missing. Also triggers the given mutation-merge if available.

merge-mutation-joins clj/s

(merge-mutation-joins state query data-tree)

Merge all of the mutations that were joined with a query

mounted? clj/s

(mounted? x)

Returns true if the component is mounted.

nf clj/s

nil-or-map? clj/s

(nil-or-map? x)

nilify-not-found clj/s

(nilify-not-found x)

Given x, return x value unless it's ::prim/not-found, in which case it returns nil.

This is useful when you wanna do a nil check but you are in a position where the value could be ::prim/not-found (and you want to consider it as nil). A common pattern looks like: `(or (prim/nilify-not-found x) 10)

normalize-query clj/s

(normalize-query state-map query)

Given a state map and a query, returns a state map with the query normalized into the database. Query fragments that already appear in the state will not be added.

normalize-query-elements clj/s

(normalize-query-elements state-map query)

Determines if there are query elements in the present query that need to be normalized as well. If so, it does so. Returns the new state map.

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).

The mutation functions return a map keyed by:

:action - The lambda to run to do the local optimistic version of that mutation any-keyword-matching-a-remote - A boolean true or AST expression of the thing to run on the named remote. :refresh - A vector of namespaced keywords of data that was/will be changed by this mutation

When the parser runs on mutations it collects the :refresh list into the metadata of the results under the :fulcro.client.primitives/refresh key.

pessimistic-transaction->transaction clj/s

(pessimistic-transaction->transaction tx)

(pessimistic-transaction->transaction
  tx
  {:keys [valid-remotes env state-map]
   :or {valid-remotes #{:remote} env {} state-map {}}
   :as options})

Converts a sequence of calls as if each call should run in sequence (deferring even the optimistic side until the prior calls have completed in a full-stack manner), and returns a tx that can be submitted via the normal transact!.

The options map can contain: valid-remotes is a set of remote names in your application. Defaults to #{:remote} env is a map that is merged into the deferred transaction's env

WARNING: If a mutation tries to interact with more than one simultaneous remote, the current implementation will wait until the first one of them completes (selected in a non-deterministic fashion), not all.

pop-pending-request clj/s

(pop-pending-request reconciler remote)

Pops request from a queue in the reconciler. This queue is not used for internal processing, only because the contents of core.async channels are opaque.

pre-merge clj/s

(pre-merge class data)

pre-merge-transform clj/s

(pre-merge-transform state)

Transform function that modifies data using component pre-merge hook.

props clj/s≠

(props component)

cljs

Return a components props.

ptransact! clj/s

(ptransact! comp-or-reconciler tx)

(ptransact! comp-or-reconciler ref tx)

Like transact!, but ensures each call completes (in a full-stack, pessimistic manner) before the next call starts in any way. Note that two calls of this function have no guaranteed relationship to each other. They could end up intermingled at runtime. The only guarantee is that for a single call to ptransact!, the calls in the given tx will run pessimistically (one at a time) in the order given. Follow-on reads in the given transaction will be repeated after each remote interaction.

comp-or-reconciler a mounted component or reconciler tx the tx to run ref the ident (ref context) in which to run the transaction (including all deferrals)

NOTE: ptransact! is safe to use from within mutations (e.g. for retry behavior). WARNINGS: Mutations that interact with more than one remote at the same time will only wait for one of the remotes to finish. Also, mutations that just issue loads should not be used. This function defers pessimistic writes, not reads.

query->ast clj/s

(query->ast query-expr)

Given a query expression convert it into an AST.

query->ast1 clj/s

(query->ast1 query-expr)

Call query->ast and return the first children.

query-id clj/s

(query-id class qualifier)

Returns a string ID for the query of the given class with qualifier

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)

DEPRECATED: Use set-state! which is a React-level primitive now.

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≠

clj

(reader in)

(reader in opts)

cljs

(reader)

(reader opts)

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

Reconciler cljs

reconciler clj/s≠

clj

(reconciler {:keys [id state shared shared-fn hydrate? parser normalize send
                    merge-sends remotes merge-tree merge-ident lifecycle
                    root-render root-unmount root-hydrate migrate render-mode
                    instrument tx-listen load-marker-default
                    query-transform-default history]
             :or {root-render (fn clj-root-render [c target] c)
                  root-hydrate (fn clj-root-hydrate [c target] c)
                  merge-sends (fn* [p1__12207# p2__12208#]
                                   (merge-with into p1__12207# p2__12208#))
                  remotes [:remote]
                  render-mode :normal
                  history 200
                  lifecycle nil
                  root-unmount (fn clj-unmount [x])
                  hydrate? false}
             :as config})

cljs

(reconciler
  {:keys [id state shared shared-fn hydrate? parser normalize send merge-sends
          remotes merge-tree merge-ident lifecycle root-render root-unmount
          root-hydrate migrate render-mode instrument tx-listen
          load-marker-default query-transform-default history]
   :or {root-render (fn* [p1__116944# p2__116945#]
                         (js/ReactDOM.render p1__116944# p2__116945#))
        root-hydrate (fn* [p1__116946# p2__116947#]
                          (js/ReactDOM.hydrate p1__116946# p2__116947#))
        merge-sends (fn* [p1__116942# p2__116943#]
                         (merge-with into p1__116942# p2__116943#))
        remotes [:remote]
        render-mode :normal
        history 200
        lifecycle nil
        root-unmount (fn* [p1__116948#]
                          (js/ReactDOM.unmountComponentAtNode p1__116948#))
        hydrate? false}
   :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: :id - a unique ID that this reconciler will be known as. Used to resolve global variable usage when more than one app is on a page. If left unspecified it will default to a random UUID. :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. :history - A positive integer. The number of history steps to keep in memory. :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] :hydrate? - Bolean. When true, it indicates the the first render should assume the server pre-rendered a DOM, which will cause a call to hydrate instead of render (React 16+). :root-render - the root render function. Defaults to ReactDOM.render :root-hydrate - the root hydrate function. Defaults to ReactDOM.hydrate. Only used on initial render, and only if :hydrate? is true. :root-unmount - the root unmount function. Defaults to ReactDOM.unmountComponentAtNode :render-mode - :normal - fastest, and the default. Components with idents can refresh in isolation. shouldComponentUpdate returns false if state/data are unchanged. Follow-on reads are required to refresh non-local concerns. :keyframe - Every data change runs a root-level query and re-renders from root. shouldComponentUpdate is the same as :default. Follow-on reads are not needed for non-local UI refresh. :brutal - Every data change runs a root-level query, and re-renders from root. shouldComponentUpdate always returns true, forcing full React diff. Not really useful for anything but benchmarking. :lifecycle - A function (fn [component event]) that is called when react components either :mount or :unmount. Useful for debugging tools. :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 history-step (see history). It also contains a couple of legacy fields for bw compatibility with 1.0.

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. x is anything any->reconciler accepts.

remove-loads-and-fallbacks clj/s

(remove-loads-and-fallbacks query)

Removes all fulcro/load and tx/fallback mutations from the query

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

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

reshape-map clj

reshape-map-clj clj

resolve-tempids clj/s

(resolve-tempids state tid->rid)

Replaces all tempids in app-state with the ids returned by the server.

rewrite-tempids-in-request-queue clj/s

(rewrite-tempids-in-request-queue queue tempid-map)

Rewrite any pending requests in the request queue to account for the fact that a response might have changed ids that are expressed in the mutations of that queue. tempid-map MUST be a map from om tempid to real ids, not idents.

roots clj/s

sc clj/s macro

(sc & args)

Just like defsc, but returns the component instead. The arguments are the same, except do not supply a symbol:

(let [C (prim/sc [this props] ...)] ...)

schedule-render! clj/s≠

clj

(schedule-render! r)

cljs

(schedule-render! reconciler)

schedule-sends! clj/s

(schedule-sends! reconciler)

set-query! clj/s

(set-query! x class-or-factory {:keys [query params follow-on-reads] :as opts})

Set a dynamic query. Alters the query, and then rebuilds internal indexes.

x is anything that any->reconciler accepts.

set-query* clj/s

(set-query* state-map class-or-factory {:keys [query] :as args})

Put a query in app state. NOTE: Indexes must be rebuilt after setting a query, so this function should primarily be used to build up an initial app state.

set-state! clj/s≠

clj

(set-state! component new-state)

(set-state! component new-state cb)

cljs

(set-state! component new-state)

(set-state! component new-state callback)

Shallow merge new-state into the state of this component. This is asynchronous and will NOT be reflected by get-state immediately, since the underlying React setState and will trigger an refresh according to React rules (see React dos for the version you're using).

This function manages a cljs map within React props, and does the shallow merge by key, so setting state:

{:x 1}

against an existing state of {:y 2} will yield:

{:x 1 :y 2}

The callback is as described in the React docs (it is invoked after the state is updated).

If you want to control the update function itself, use update-state!.

If you're wanting low-level js interop to affect low-level js props: use React's setState.

shared clj/s

(shared component)

(shared component k-or-ks)

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

some-hasquery? clj/s

(some-hasquery? c)

Returns true if the given component or one of its parents has a query.

strip-ui clj/s

(strip-ui query)

Returns a new query with fragments that are in the ui namespace removed.

sweep clj/s

(sweep m)

Remove all of the not-found keys (recursively) from v, stopping at marked leaves (if present)

sweep-merge clj/s

(sweep-merge target source)

Do a recursive merge of source into target, but remove any target data that is marked as missing in the response. The missing marker is generated in the source when something has been asked for in the query, but had no value in the response. This allows us to correctly remove 'empty' data from the database without accidentally removing something that may still exist on the server (in truth we don't know its status, since it wasn't asked for, but we leave it as our 'best guess')

sweep-one clj/s

(sweep-one m)

Remove not-found keys from m (non-recursive)

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:

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

NOTE: transact! is not safe to call from within mutations unless you defer it inside of a setTimeout. This is because otherwise you could potentially nest calls of swap! that will cause unexpected results. In general it the model of Fulcro is such that a call transact! within a mutation is technically just bad design. If you need pessimistic UI control, see ptransact! instead.

transact* clj/s

(transact* reconciler c ref tx)

Internal implementation detail of transact!. Call that function instead.

tree->db clj/s

(tree->db x data)

(tree->db x data merge-idents)

(tree->db x data merge-idents transform)

Given a 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

(ui & forms)

Declare an anonymous UI component. If the first argument is a keyword, then it is treated as the React version (defaults to :v15).

union->query clj/s

(union->query union-query)

Turn a union query into a query that attempts to encompass all possible things that might be queried

update-state! clj/s

(update-state! component f)

(update-state! component f & args)

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

This function affects a managed cljs map maintained in React state. If you want to affect the low-level js state itself use React's own .setState on the component.

validate-statics clj/s

(validate-statics dt)

with-parent-context clj/s macro

(with-parent-context outer-parent & body)

Wraps the given body with the correct internal bindings of the parent so that Fulcro internals will work when that body is embedded in unusual ways (e.g. as the body in a child-as-a-function React pattern).

writer clj/s

(writer)

(writer opts)

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