fulcro.client.primitives — fulcrologic/fulcro 2.5.11

*blindly-render* clj/s

*depth* clj/s

*instrument* clj/s

*parent* clj/s

*raf* clj/s

*reconciler* clj/s

*shared* clj/s

-next-props cljs

(-next-props next-props component)

-prev-props cljs

(-prev-props prev-props component)

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

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

class->any clj/s

(class->any x class)

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

collect-statics clj/s

(collect-statics dt)

Collect the static declarations from the defui.

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? clj/s

(component? x)

Returns true if the argument is a component.

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

deep-merge clj/s

(deep-merge & xs)

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
   :css [] ; garden css rules
   :css-include [] ; list of components that have CSS to compose towards root.

   ; React Lifecycle Methods (this in scope)
   :initLocalState            (fn [] ...)
   :shouldComponentUpdate     (fn [next-props next-state] ...)
   :componentWillReceiveProps (fn [next-props] ...)
   :componentWillUpdate       (fn [next-props next-state] ...)
   :componentDidUpdate        (fn [prev-props prev-state] ...)
   :componentWillMount        (fn [] ...)
   :componentDidMount         (fn [] ...)
   :componentWillUnmount      (fn [] ...)
   ;; React 16:
   :componentDidCatch         (fn [error info])

   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* args)

defui clj/s macro

(defui name & forms)

defui* clj/s

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

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! reconciler)

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.

force-update cljs

(force-update c)

(force-update c cb)

An exception-protected React .forceUpdate

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

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-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-query? clj/s

(has-query? 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 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)

Integrate an ident into any number of places in the app state. This function is safe to use within mutation implementations as a general helper function.

The named parameters can be specified any number of times. They are:

• append: A vector (path) to a list in your app state where this new object's ident should be appended. Will not append the ident if that ident is already in the list.
• prepend: A vector (path) to a list in your app state where this new object's ident should be prepended. Will not append the ident if that ident is already in the list.
• replace: A vector (path) to a specific location in app-state where this object's ident should be placed. Can target a to-one or to-many. If the target is a vector element then that element must already exist in the vector.

integrate-ident! clj/s

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

Integrate an ident into any number of places in the app state. This function is safe to use within mutation implementations as a general helper function.

The named parameters can be specified any number of times. They are:

• append: A vector (path) to a list in your app state where this new object's ident should be appended. Will not append the ident if that ident is already in the list.
• prepend: A vector (path) to a list in your app state where this new object's ident should be prepended. Will not append the ident if that ident is already in the list.
• replace: A vector (path) to a specific location in app-state where this object's ident should be placed. Can target a to-one or to-many. If the target is a vector element then that element must already exist in the vector.

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)

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/s

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)

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)

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.

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)

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 parser normalize send merge-sends
                    remotes merge-tree merge-ident optimize lifecycle
                    root-render root-unmount migrate render-mode instrument
                    tx-listen history]
             :or {merge-sends (fn* [p1__12876# p2__12877#]
                                   (merge-with into p1__12876# p2__12877#))
                  remotes [:remote]
                  render-mode :normal
                  history 200
                  lifecycle nil
                  optimize (fn depth-sorter [cs] (sort-by depth cs))
                  root-render (fn clj-root-render [c target] c)
                  root-unmount (fn clj-unmount [x])}
             :as config})

cljs

(reconciler
  {:keys [id state shared shared-fn parser normalize send merge-sends remotes
          merge-tree merge-ident optimize lifecycle root-render root-unmount
          migrate render-mode instrument tx-listen history]
   :or {merge-sends (fn* [p1__26334# p2__26335#]
                         (merge-with into p1__26334# p2__26335#))
        remotes [:remote]
        render-mode :normal
        history 200
        lifecycle nil
        optimize (fn depth-sorter [cs] (sort-by depth cs))
        root-render (fn* [p1__26336# p2__26337#]
                         (js/ReactDOM.render p1__26336# p2__26337#))
        root-unmount (fn* [p1__26338#]
                          (js/ReactDOM.unmountComponentAtNode p1__26338#))}
   :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] :root-render - the root render function. Defaults to ReactDOM.render :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.

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/s

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

reshape-map clj/s

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! cljs

(schedule-render! reconciler)

schedule-sends! clj/s

(schedule-sends! reconciler)

set-query! clj/s

(set-query! component-or-reconciler
            ui-factory-or-queryid
            {:keys [query params follow-on-reads] :as opts})

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

set-query* clj/s

(set-query* state-map ui-factory-class-or-queryid {: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≠

(set-state! component new-state)

cljs

Set the component local state of the component. Analogous to React's setState. WARNING: This version triggers a reconcile which will run the query on the component. This is to avoid spurious overhead of multiple renders on the DOM by pushing the refresh off to the next animation frame; however, rapid animation updates will not work well with this. Use react-set-state! instead. This function may evolve in the future to just be the same as react-set-state!. Your feedback is welcome.

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.

should-update? cljs

(should-update? c next-props)

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

Invoke the lifecycle method on the component to see if it would recommend an update given the next-props or next-props and next-state

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)

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)

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

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.