The implementation of processing load/mutation result graph targeting.

The algorithm and support functions for converting a normalized Fulcro database to a tree of denormalized props.

Some misc. utility functions. These are primarily meant for internal use, and are subject to
relocation and removal in the future.

You have been warned. Changes to this ns (or its complete removal)
will not be considered breaking changes to the library, and no mention of said changes
will even appear in the changelog.

Functions that assist with supporting form editing/checking/diffing in Fulcro UI.  These functions work
by making a pristine copy of your entity, and tracking what fields have been touched.  You are responsible
for triggering these various states by marking fields as complete (`mark-complete!`), telling it to
copy the data to/from pristine (e.g. `entity->pristine`), and by asking for out-of-date data for the current
vs. pristine copy (`dirty-fields`).

There is also support for detecting which fields have been marked complete and are dirty.

Validation can be done via Clojure spec, or by defining your own field validation functions via
`make-validator`. This general-purpose validation factor function can easily be used to create more
automated validation factories that can be more configuration-driven, but this is left as an exercise for the community.

See the Developer's Guide for more information.

Functions that implement the query and component indexing.

Namespace with support for finding plug-in algorithms on the app. Avoids circular references
within the library itself.

Various algorithms that are used for merging trees of data into a normalized Fulcro database.

Functions for dealing with normalizing Fulcro databases. In particular `tree->db`.

Algorithms for delaying some action by a particular amount of time.

Functions for making and consuming Fulcro temporary IDs.

(ns app.development-preload
  (:require
    [taoensso.timbre :as log]
    [com.fulcrologic.fulcro.algorithms.timbre-support :refer [console-appender prefix-output-fn]))

(log/set-level! :debug)
(log/merge-config! {:output-fn prefix-output-fn
                    :appenders {:console (console-appender)}})

(try
  ...
  (catch :default ex
    (log/error ex ...))

Logging helpers to make js console logging more readable. The recommended use of these functions is as follows:

- Make sure you're using Binaryage devtools (on classpath. shadow-cljs will auto-add it when detected).
- IMPORTANT: Enable custom formatters in console settings for Chrome. This will print cljs data as cljs (instead of raw js).
- Make a development preload cljs file, and tell shadow-cljs to preload it.
- In the preload file, add something like this:

```
(ns app.development-preload
  (:require
    [taoensso.timbre :as log]
    [com.fulcrologic.fulcro.algorithms.timbre-support :refer [console-appender prefix-output-fn]))

(log/set-level! :debug)
(log/merge-config! {:output-fn prefix-output-fn
                    :appenders {:console (console-appender)}})
```

and you'll get much more readable error messages in the js console.

NOTE: when logging errors, be sure to log the exception first. This is documented in timbre, but easy to miss:

```
(try
  ...
  (catch :default ex
    (log/error ex ...))
```

See the development_preload.cljs and shadow-cljs.edn files in the latest Fulcro 3 template for an example.

Transit functions for the on-the-wire EDN communication to common remotes. Includes support for Fulcro tempids,
and can be extended to support additional application-specific data types.

The transaction processing in Fulcro is pluggable. This namespace is the
implementation for the default transaction processing .

Helper functions for debugging tx processing.  Uses pprint, which adds
a lot to build size, so it is in a separate ns to keep it out of prod builds.

Support for rendering DOM from CLJ. Must be separate to enable same-named macros in CLJS for performance.

Usage: Create your UI in CLJC files, and require with conditional reader tags:

(ns app.ui
  (:require
    #?(:clj [com.fulcrologic.fulcro.dom-server :as dom] :cljs [com.fulcrologic.fulcro.dom :as dom])))

Utility functions for working with low-level synthetic js events on the DOM

(ns my.ui
  (:require
    [com.fulcrologic.fulcro.dom.html-entities :as ent]))
    
...
   (dom/div ent/nbsp ent/copy)
...

Defs of the proper unicode characters so you can use html entities in your DOM functions without having to
look them up (or type out silly things like "\u00C6"

For example:

```
(ns my.ui
  (:require
    [com.fulcrologic.fulcro.dom.html-entities :as ent]))
    
...
   (dom/div ent/nbsp ent/copy)
...
```

SVG-encoded material UI icons.

See https://material-ui.com/components/icons

Internal algorithms for sending db diffs to Inspect tool.

Functions used by Fulcro to talk to Fulcro Inspect.

Namespace to use in your compiler preload in order to enable inspect support during development.

Simple adapter code that allows you to use a generic parser 'as if' it were a client remote in CLJS.

A render optimization algorithm for refreshing the UI via props tunnelling (setting new props on a component's
state in a pre-agreed location). This algorithm analyzes database changes and on-screen components to update
components (by ident) whose props have changed.

Prop change detection is done by scanning the database in *only* the locations that on-screen components are querying
(derived by the mounted component idents, and any ident-joins in the queries).

The keyframe optimized render.

Routers from Fulcro 2. These are a bit harder to use than the new dynamic router, and should probably not be used
in new applications; however, they will be supported for the forseeable future.

Utilities for managing server configuration via EDN files.  These functions expect a config/defaults.edn to exist
on the classpath as a definition for server configuration default values.  When you call `load-config!` it will
deep merge the file you supply with the base defaults to return the 'complete' configuration.  When loading
configurations a relative path is evaluated against CLASSPATH and an absolute path against the real filesystem.

The values in the EDN files can be :env/VAR to pull a string from an env variable, and :env.edn/VAR to do a `read-string`
against the value of an environment variable.