create-expo-cljs-app
Version:
Create a react native application with Expo and Shadow-CLJS!
1 lines • 216 kB
JSON
["^ ","~:output",["^ ","~:js","goog.provide('re_frame.core');\n/**\n * Queue `event` for processing (handling). \n * \n * `event` is a vector and the first element is typically a keyword\n * which identifies the kind of event.\n * \n * The event will be added to a FIFO processing queue, so event\n * handling does not happen immediately. It will happen 'very soon'\n * bit not now. And if the queue already contains events, they\n * will be processed first.\n * \n * Usage:\n * \n * (dispatch [:order \"pizza\" {:supreme 2 :meatlovers 1 :veg 1}])\n * \n */\nre_frame.core.dispatch = (function re_frame$core$dispatch(event){\nreturn re_frame.router.dispatch(event);\n});\n/**\n * Synchronously (immediately) process `event`. It does **not** queue\n * the event for handling later as `dispatch` does. \n * \n * `event` is a vector and the first element is typically a keyword \n * which identifies the kind of event.\n * \n * It is an error to use `dispatch-sync` within an event handler because \n * you can't immediately process an new event when one is already\n * part way through being processed.\n * \n * Generally, avoid using this function, and instead, use `dispatch`. \n * Only use it in the narrow set of cases where any delay in \n * processing is a problem:\n * \n * 1. the `:on-change` handler of a text field where we are expecting fast typing\n * 2. when initialising your app - see 'main' in examples/todomvc/src/core.cljs\n * 3. in a unit test where immediate, synchronous processing is useful\n * \n * Usage:\n * \n * (dispatch-sync [:sing :falsetto \"piano accordion\"])\n * \n */\nre_frame.core.dispatch_sync = (function re_frame$core$dispatch_sync(event){\nreturn re_frame.router.dispatch_sync(event);\n});\n/**\n * A call to `reg-sub` associates a `query-id` WITH two functions.\n * \n * The two functions provide 'a mechanism' for creating a node \n * in the Signal Graph. When a node of type `query-id` is needed, \n * the two functions can be used to create it.\n * \n * The three arguments are: \n * \n * - `query-id` - typically a namespaced keyword (later used in subscribe)\n * - optionally, an `input signals` function which returns the input data\n * flows required by this kind of node. \n * - a `computation function` which computes the value (output) of the \n * node (from the input data flows)\n * \n * Later, during app execution, a call to `(subscribe [:sub-id 3 :blue])`,\n * will trigger the need for a new `:sub-id` Signal Graph node (matching the \n * query `[:sub-id 3 :blue]`). And, to create that node the two functions \n * associated with `:sub-id` will be looked up and used.\n * \n * Just to be clear: calling `reg-sub` does not immediately create a node. \n * It only registers 'a mechanism' (the two functions) by which nodes \n * can be created later, when a node is bought into existence by the \n * use of `subscribe` in a `View Function`.\n * \n * The `computation function` is expected to take two arguments:\n * \n * - `input-values` - the values which flow into this node (how is it wierd into the graph?)\n * - `query-vector` - the vector given to `subscribe`\n * \n * and it returns a computed value (which then becomes the output of the node)\n * \n * When `computation function` is called, the 2nd `query-vector` argument will be that \n * vector supplied to the `subscribe`. So, if the call was `(subscribe [:sub-id 3 :blue])`,\n * then the `query-vector` supplied to the computaton function will be `[:sub-id 3 :blue]`.\n * \n * The argument(s) supplied to `reg-sub` between `query-id` and the `computation-function` \n * can vary in 3 ways, but whatever is there defines the `input signals` part \n * of `the mechanism`, specifying what input values \"flow into\" the \n * `computation function` (as the 1st argument) when it is called.\n * \n * So, `reg-sub` can be called in one of three ways, because there are three ways \n * to define the input signals part. But note, the 2nd method, in which a \n * `signals function` is explicitly supplied, is the most canonical and \n * instructive. The other two are really just sugary variations.\n * \n * **First variation** - no input signal function given:\n * \n * (reg-sub\n * :query-id\n * a-computation-fn) ;; has signature: (fn [db query-vec] ... ret-value)\n * \n * In the absence of an explicit `signals function`, the node's input signal defaults to `app-db`\n * and, as a result, the value within `app-db` (a map) is\n * is given as the 1st argument when `a-computation-fn` is called.\n * \n * \n * **Second variation** - a signal function is explicitly supplied:\n * \n * (reg-sub\n * :query-id\n * signal-fn ;; <-- here\n * computation-fn)\n * \n * This is the most canonical and instructive of the three variations.\n * \n * When a node is created from the template, the `signal function` will be called and it\n * is expected to return the input signal(s) as either a singleton, if there is only\n * one, or a sequence if there are many, or a map with the signals as the values.\n * \n * The current values of the returned signals will be supplied as the 1st argument to\n * the `a-computation-fn` when it is called - and subject to what this `signal-fn` returns,\n * this value will be either a singleton, sequence or map of them (paralleling\n * the structure returned by the `signal function`).\n * \n * This example `signal function` returns a 2-vector of input signals.\n * \n * (fn [query-vec dynamic-vec]\n * [(subscribe [:a-sub])\n * (subscribe [:b-sub])])\n * \n * The associated computation function must be written\n * to expect a 2-vector of values for its first argument:\n * \n * (fn [[a b] query-vec] ;; 1st argument is a seq of two values\n * ....)\n * \n * If, on the other hand, the signal function was simpler and returned a singleton, like this:\n * \n * (fn [query-vec dynamic-vec]\n * (subscribe [:a-sub])) ;; <-- returning a singleton\n * \n * then the associated computation function must be written to expect a single value\n * as the 1st argument:\n * \n * (fn [a query-vec] ;; 1st argument is a single value\n * ...)\n * \n * Further Note: variation #1 above, in which an `input-fn` was not supplied, like this:\n * \n * (reg-sub\n * :query-id\n * a-computation-fn) ;; has signature: (fn [db query-vec] ... ret-value)\n * \n * is the equivalent of using this\n * 2nd variation and explicitly suppling a `signal-fn` which returns `app-db`:\n * \n * (reg-sub\n * :query-id\n * (fn [_ _] re-frame/app-db) ;; <--- explicit signal-fn\n * a-computation-fn) ;; has signature: (fn [db query-vec] ... ret-value)\n * \n * **Third variation** - syntax Sugar\n * \n * (reg-sub\n * :a-b-sub\n * :<- [:a-sub]\n * :<- [:b-sub]\n * (fn [[a b] query-vec] ;; 1st argument is a seq of two values\n * {:a a :b b}))\n * \n * This 3rd variation is just syntactic sugar for the 2nd. Instead of providing an\n * `signals-fn` you provide one or more pairs of `:<-` and a subscription vector.\n * \n * If you supply only one pair a singleton will be supplied to the computation function,\n * as if you had supplied a `signal-fn` returning only a single value:\n * \n * \n * (reg-sub\n * :a-sub\n * :<- [:a-sub]\n * (fn [a query-vec] ;; only one pair, so 1st argument is a single value\n * ...))\n * \n * For further understanding, read the tutorials, and look at the detailed comments in\n * /examples/todomvc/src/subs.cljs.\n * \n * See also: `subscribe`\n * \n */\nre_frame.core.reg_sub = (function re_frame$core$reg_sub(var_args){\nvar args__4742__auto__ = [];\nvar len__4736__auto___49439 = arguments.length;\nvar i__4737__auto___49440 = (0);\nwhile(true){\nif((i__4737__auto___49440 < len__4736__auto___49439)){\nargs__4742__auto__.push((arguments[i__4737__auto___49440]));\n\nvar G__49441 = (i__4737__auto___49440 + (1));\ni__4737__auto___49440 = G__49441;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__4743__auto__ = ((((1) < args__4742__auto__.length))?(new cljs.core.IndexedSeq(args__4742__auto__.slice((1)),(0),null)):null);\nreturn re_frame.core.reg_sub.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4743__auto__);\n});\n\n(re_frame.core.reg_sub.cljs$core$IFn$_invoke$arity$variadic = (function (query_id,args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(re_frame.subs.reg_sub,cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [query_id], null),args));\n}));\n\n(re_frame.core.reg_sub.cljs$lang$maxFixedArity = (1));\n\n/** @this {Function} */\n(re_frame.core.reg_sub.cljs$lang$applyTo = (function (seq49163){\nvar G__49164 = cljs.core.first(seq49163);\nvar seq49163__$1 = cljs.core.next(seq49163);\nvar self__4723__auto__ = this;\nreturn self__4723__auto__.cljs$core$IFn$_invoke$arity$variadic(G__49164,seq49163__$1);\n}));\n\n/**\n * Given a `query` vector, returns a Reagent `reaction` which will, over\n * time, reactively deliver a stream of values. So, in FRP-ish terms,\n * it returns a `Signal`.\n * \n * To obtain the current value from the Signal, it must be dereferenced: \n * \n * (let [signal (subscribe [:items])\n * value (deref signal)] ;; could be written as @signal\n * ...)\n * \n * which is typically written tersely as simple:\n * \n * (let [items @(subscribe [:items])] \n * ...)\n * \n * \n * `query` is a vector of at least one element. The first element is the\n * `query-id`, typically a namespaced keyword. The rest of the vector's\n * elements are optional, additional values which parameterise the query\n * performed.\n * \n * `dynv` is an optional 3rd argument, which is a vector of further input\n * signals (atoms, reactions, etc), NOT values. This argument exists for\n * historical reasons and is borderline deprecated these days.\n * \n * **Example Usage**:\n * \n * (subscribe [:items])\n * (subscribe [:items \"blue\" :small])\n * (subscribe [:items {:colour \"blue\" :size :small}])\n * \n * Note: for any given call to `subscribe` there must have been a previous call\n * to `reg-sub`, registering the query handler (functions) associated with \n * `query-id`.\n * \n * **Hint**\n * \n * When used in a view function BE SURE to `deref` the returned value.\n * In fact, to avoid any mistakes, some prefer to define:\n * \n * (def <sub (comp deref re-frame.core/subscribe))\n * \n * And then, within their views, they call `(<sub [:items :small])` rather\n * than using `subscribe` directly.\n * \n * **De-duplication**\n * \n * Two, or more, concurrent subscriptions for the same query will \n * source reactive updates from the one executing handler.\n * \n * See also: `reg-sub`\n * \n */\nre_frame.core.subscribe = (function re_frame$core$subscribe(var_args){\nvar G__49179 = arguments.length;\nswitch (G__49179) {\ncase 1:\nreturn re_frame.core.subscribe.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn re_frame.core.subscribe.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.subscribe.cljs$core$IFn$_invoke$arity$1 = (function (query){\nreturn re_frame.subs.subscribe.cljs$core$IFn$_invoke$arity$1(query);\n}));\n\n(re_frame.core.subscribe.cljs$core$IFn$_invoke$arity$2 = (function (query,dynv){\nreturn re_frame.subs.subscribe.cljs$core$IFn$_invoke$arity$2(query,dynv);\n}));\n\n(re_frame.core.subscribe.cljs$lang$maxFixedArity = 2);\n\n/**\n * Unregisters subscription handlers (presumably registered previously via the use of `reg-sub`). \n * \n * When called with no args, it will unregister all currently registered subscription handlers. \n * \n * When given one arg, assumed to be the `id` of a previously registered \n * subscription handler, it will unregister the associated handler. Will produce a warning to \n * console if it finds no matching registration.\n * \n * NOTE: Depending on the usecase, it may be necessary to call `clear-subscription-cache!` afterwards\n */\nre_frame.core.clear_sub = (function re_frame$core$clear_sub(var_args){\nvar G__49195 = arguments.length;\nswitch (G__49195) {\ncase 0:\nreturn re_frame.core.clear_sub.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn re_frame.core.clear_sub.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.clear_sub.cljs$core$IFn$_invoke$arity$0 = (function (){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1(re_frame.subs.kind);\n}));\n\n(re_frame.core.clear_sub.cljs$core$IFn$_invoke$arity$1 = (function (query_id){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2(re_frame.subs.kind,query_id);\n}));\n\n(re_frame.core.clear_sub.cljs$lang$maxFixedArity = 1);\n\n/**\n * Removes all subscriptions from the cache.\n * \n * This function can be used at development time or test time. Useful when hot realoding\n * namespaces containing subscription handlers. Also call it after a React/render exception,\n * because React components won't have been cleaned up properly. And this, in turn, means \n * the subscriptions within those components won't have been cleaned up correctly. So this \n * forces the issue.\n * \n */\nre_frame.core.clear_subscription_cache_BANG_ = (function re_frame$core$clear_subscription_cache_BANG_(){\nreturn re_frame.subs.clear_subscription_cache_BANG_();\n});\n/**\n * This is a low level, advanced function. You should probably be\n * using `reg-sub` instead.\n * \n * Some explanation is available in the docs at\n * <a href=\"http://day8.github.io/re-frame/flow-mechanics/\" target=\"_blank\">http://day8.github.io/re-frame/flow-mechanics/</a>\n */\nre_frame.core.reg_sub_raw = (function re_frame$core$reg_sub_raw(query_id,handler_fn){\nreturn re_frame.registrar.register_handler(re_frame.subs.kind,query_id,handler_fn);\n});\n/**\n * Register the given effect `handler` for the given `id`:\n * \n * - `id` is keyword, often namespaced.\n * - `handler` is a side-effecting function which takes a single argument and whose return\n * value is ignored.\n * \n * To use, first, associate `:effect2` with a handler:\n * \n * (reg-fx\n * :effect2\n * (fn [value]\n * ... do something side-effect-y))\n * \n * Then, later, if an event handler were to return this effects map:\n * \n * {:effect2 [1 2]}\n * \n * then the `handler` `fn` we registered previously, using `reg-fx`, will be\n * called with an argument of `[1 2]`.\n * \n */\nre_frame.core.reg_fx = (function re_frame$core$reg_fx(id,handler){\nreturn re_frame.fx.reg_fx(id,handler);\n});\n/**\n * Unregisters effect handlers (presumably registered previously via the use of `reg-fx`). \n * \n * When called with no args, it will unregister all currently registered effect handlers. \n * \n * When given one arg, assumed to be the `id` of a previously registered \n * effect handler, it will unregister the associated handler. Will produce a warning to \n * console if it finds no matching registration.\n * \n */\nre_frame.core.clear_fx = (function re_frame$core$clear_fx(var_args){\nvar G__49219 = arguments.length;\nswitch (G__49219) {\ncase 0:\nreturn re_frame.core.clear_fx.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn re_frame.core.clear_fx.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.clear_fx.cljs$core$IFn$_invoke$arity$0 = (function (){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1(re_frame.fx.kind);\n}));\n\n(re_frame.core.clear_fx.cljs$core$IFn$_invoke$arity$1 = (function (id){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2(re_frame.fx.kind,id);\n}));\n\n(re_frame.core.clear_fx.cljs$lang$maxFixedArity = 1);\n\n/**\n * Register the given coeffect `handler` for the given `id`, for later use\n * within `inject-cofx`:\n * \n * - `id` is keyword, often namespaced.\n * - `handler` is a function which takes either one or two arguements, the first of which is\n * always `coeffects` and which returns an updated `coeffects`.\n * \n * See also: `inject-cofx` \n * \n */\nre_frame.core.reg_cofx = (function re_frame$core$reg_cofx(id,handler){\nreturn re_frame.cofx.reg_cofx(id,handler);\n});\n/**\n * Given an `id`, and an optional, arbitrary `value`, returns an interceptor\n * whose `:before` adds to the `:coeffects` (map) by calling a pre-registered\n * 'coeffect handler' identified by the `id`.\n * \n * The previous association of a `coeffect handler` with an `id` will have\n * happened via a call to `re-frame.core/reg-cofx` - generally on program startup.\n * \n * Within the created interceptor, this 'looked up' `coeffect handler` will\n * be called (within the `:before`) with two arguments:\n * \n * - the current value of `:coeffects`\n * - optionally, the originally supplied arbitrary `value`\n * \n * This `coeffect handler` is expected to modify and return its first, `coeffects` argument.\n * \n * **Example of `inject-cofx` and `reg-cofx` working together**\n * \n * \n * First - Early in app startup, you register a `coeffect handler` for `:datetime`:\n * \n * (re-frame.core/reg-cofx\n * :datetime ;; usage (inject-cofx :datetime)\n * (fn coeffect-handler\n * [coeffect]\n * (assoc coeffect :now (js/Date.)))) ;; modify and return first arg\n * \n * Second - Later, add an interceptor to an -fx event handler, using `inject-cofx`:\n * \n * (re-frame.core/reg-event-fx ;; when registering an event handler\n * :event-id\n * [ ... (inject-cofx :datetime) ... ] ;; <-- create an injecting interceptor\n * (fn event-handler\n * [coeffect event]\n * ;;... in here can access (:now coeffect) to obtain current datetime ... \n * )))\n * \n * **Background**\n * \n * `coeffects` are the input resources required by an event handler\n * to perform its job. The two most obvious ones are `db` and `event`.\n * But sometimes an event handler might need other resources.\n * \n * Perhaps an event handler needs a random number or a GUID or the current\n * datetime. Perhaps it needs access to a DataScript database connection.\n * \n * If an event handler directly accesses these resources, it stops being\n * pure and, consequently, it becomes harder to test, etc. So we don't\n * want that.\n * \n * Instead, the interceptor created by this function is a way to 'inject'\n * 'necessary resources' into the `:coeffects` (map) subsequently given\n * to the event handler at call time.\n * \n * See also `reg-cofx`\n * \n */\nre_frame.core.inject_cofx = (function re_frame$core$inject_cofx(var_args){\nvar G__49237 = arguments.length;\nswitch (G__49237) {\ncase 1:\nreturn re_frame.core.inject_cofx.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn re_frame.core.inject_cofx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.inject_cofx.cljs$core$IFn$_invoke$arity$1 = (function (id){\nreturn re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$1(id);\n}));\n\n(re_frame.core.inject_cofx.cljs$core$IFn$_invoke$arity$2 = (function (id,value){\nreturn re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$2(id,value);\n}));\n\n(re_frame.core.inject_cofx.cljs$lang$maxFixedArity = 2);\n\n/**\n * Unregisters coeffect handlers (presumably registered previously via the use of `reg-cofx`). \n * \n * When called with no args, it will unregister all currently registered coeffect handlers. \n * \n * When given one arg, assumed to be the `id` of a previously registered \n * coeffect handler, it will unregister the associated handler. Will produce a warning to \n * console if it finds no matching registration.\n */\nre_frame.core.clear_cofx = (function re_frame$core$clear_cofx(var_args){\nvar G__49249 = arguments.length;\nswitch (G__49249) {\ncase 0:\nreturn re_frame.core.clear_cofx.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn re_frame.core.clear_cofx.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.clear_cofx.cljs$core$IFn$_invoke$arity$0 = (function (){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1(re_frame.cofx.kind);\n}));\n\n(re_frame.core.clear_cofx.cljs$core$IFn$_invoke$arity$1 = (function (id){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2(re_frame.cofx.kind,id);\n}));\n\n(re_frame.core.clear_cofx.cljs$lang$maxFixedArity = 1);\n\n/**\n * Register the given event `handler` (function) for the given `id`. Optionally, provide\n * an `interceptors` chain:\n * \n * - `id` is typically a namespaced keyword (but can be anything)\n * - `handler` is a function: (db event) -> db\n * - `interceptors` is a collection of interceptors. Will be flattened and nils removed.\n * \n * Example Usage:\n * \n * (reg-event-db \n * :token \n * (fn [db event]\n * (assoc db :some-key (get event 2))) ;; return updated db\n * \n * Or perhaps:\n * \n * (reg-event-db\n * :namespaced/id ;; <-- namespaced keywords are often used\n * [one two three] ;; <-- a seq of interceptors\n * (fn [db [_ arg1 arg2]] ;; <-- event vector is destructured\n * (-> db \n * (dissoc arg1)\n * (update :key + arg2)))) ;; return updated db\n * \n */\nre_frame.core.reg_event_db = (function re_frame$core$reg_event_db(var_args){\nvar G__49272 = arguments.length;\nswitch (G__49272) {\ncase 2:\nreturn re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$2 = (function (id,handler){\nreturn re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$3(id,null,handler);\n}));\n\n(re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,handler){\nreturn re_frame.events.register(id,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,re_frame.std_interceptors.inject_global_interceptors,interceptors,re_frame.std_interceptors.db_handler__GT_interceptor(handler)], null));\n}));\n\n(re_frame.core.reg_event_db.cljs$lang$maxFixedArity = 3);\n\n/**\n * Register the given event `handler` (function) for the given `id`. Optionally, provide\n * an `interceptors` chain:\n * \n * - `id` is typically a namespaced keyword (but can be anything)\n * - `handler` is a function: (coeffects-map event-vector) -> effects-map\n * - `interceptors` is a collection of interceptors. Will be flattened and nils removed.\n * \n * \n * Example Usage:\n * \n * (reg-event-fx \n * :token \n * (fn [cofx event]\n * {:db (assoc (:db cofx) :some-key (get event 2))})) ;; return a map of effects\n * \n * \n * Or perhaps:\n * \n * (reg-event-fx\n * :namespaced/id ;; <-- namespaced keywords are often used\n * [one two three] ;; <-- a seq of interceptors\n * (fn [{:keys [db] :as cofx} [_ arg1 arg2]] ;; destructure both arguments\n * {:db (assoc db :some-key arg1) ;; return a map of effects\n * :dispatch [:some-event arg2]}))\n * \n */\nre_frame.core.reg_event_fx = (function re_frame$core$reg_event_fx(var_args){\nvar G__49285 = arguments.length;\nswitch (G__49285) {\ncase 2:\nreturn re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$2 = (function (id,handler){\nreturn re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$3(id,null,handler);\n}));\n\n(re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,handler){\nreturn re_frame.events.register(id,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,re_frame.std_interceptors.inject_global_interceptors,interceptors,re_frame.std_interceptors.fx_handler__GT_interceptor(handler)], null));\n}));\n\n(re_frame.core.reg_event_fx.cljs$lang$maxFixedArity = 3);\n\n/**\n * Register the given event `handler` (function) for the given `id`. Optionally, provide\n * an `interceptors` chain:\n * \n * - `id` is typically a namespaced keyword (but can be anything)\n * - `handler` is a function: (context-map event-vector) -> context-map\n * \n * This form of registration is seldomAt dinner wenever used.\n * \n */\nre_frame.core.reg_event_ctx = (function re_frame$core$reg_event_ctx(var_args){\nvar G__49288 = arguments.length;\nswitch (G__49288) {\ncase 2:\nreturn re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$2 = (function (id,handler){\nreturn re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$3(id,null,handler);\n}));\n\n(re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,handler){\nreturn re_frame.events.register(id,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,re_frame.std_interceptors.inject_global_interceptors,interceptors,re_frame.std_interceptors.ctx_handler__GT_interceptor(handler)], null));\n}));\n\n(re_frame.core.reg_event_ctx.cljs$lang$maxFixedArity = 3);\n\n/**\n * Unregisters event handlers (presumably registered previously via the use of `reg-event-db` or `reg-event-fx`). \n * \n * When called with no args, it will unregister all currently registered event handlers. \n * \n * When given one arg, assumed to be the `id` of a previously registered \n * event handler, it will unregister the associated handler. Will produce a warning to \n * console if it finds no matching registration.\n */\nre_frame.core.clear_event = (function re_frame$core$clear_event(var_args){\nvar G__49294 = arguments.length;\nswitch (G__49294) {\ncase 0:\nreturn re_frame.core.clear_event.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn re_frame.core.clear_event.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.clear_event.cljs$core$IFn$_invoke$arity$0 = (function (){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1(re_frame.events.kind);\n}));\n\n(re_frame.core.clear_event.cljs$core$IFn$_invoke$arity$1 = (function (id){\nreturn re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2(re_frame.events.kind,id);\n}));\n\n(re_frame.core.clear_event.cljs$lang$maxFixedArity = 1);\n\n/**\n * An interceptor which logs/instruments an event handler's actions to\n * `js/console.debug`. See examples/todomvc/src/events.cljs for use.\n * \n * Output includes:\n * \n * 1. the event vector\n * 2. a `clojure.data/diff` of db, before vs after, which shows\n * the changes caused by the event handler. To understand the output,\n * you should understand:\n * <a href=\"https://clojuredocs.org/clojure.data/diff\" target=\"_blank\">https://clojuredocs.org/clojure.data/diff</a>.\n * \n * You'd typically include this interceptor after (to the right of) any\n * `path` interceptor.\n * \n * Warning: calling `clojure.data/diff` on large, complex data structures\n * can be slow. So, you won't want this interceptor present in production\n * code. So, you should condition it out like this:\n * \n * (re-frame.core/reg-event-db\n * :evt-id\n * [(when ^boolean goog.DEBUG re-frame.core/debug)] ;; <-- conditional\n * (fn [db v]\n * ...))\n * \n * To make this code fragment work, you'll also have to set `goog.DEBUG` to\n * `false` in your production builds. For an example, look in `project.clj` of /examples/todomvc.\n * \n */\nre_frame.core.debug = re_frame.std_interceptors.debug;\n/**\n * Returns an interceptor which acts somewhat like `clojure.core/update-in`, in the sense that \n * the event handler is given a specific part of `app-db` to change, not all of `app-db`. \n * \n * The interceptor has both a `:before` and `:after` functions. The `:before` replaces \n * the `:db` key within coeffects with a sub-path within `app-db`. The `:after` reverses the process, \n * and it grafts the handler's return value back into db, at the right path.\n * \n * Examples:\n * \n * (path :some :path)\n * (path [:some :path])\n * (path [:some :path] :to :here)\n * (path [:some :path] [:to] :here)\n * \n * Example Use:\n * \n * (reg-event-db\n * :event-id\n * (path [:a :b]) ;; <-- used here, in interceptor chain\n * (fn [b v] ;; 1st arg is not db. Is the value from path [:a :b] within db\n * ... new-b)) ;; returns a new value for that path (not the entire db)\n * \n * Notes:\n * \n * 1. `path` may appear more than once in an interceptor chain. Progressive narrowing.\n * 2. if `:effects` contains no `:db` effect, can't graft a value back in.\n * \n */\nre_frame.core.path = (function re_frame$core$path(var_args){\nvar args__4742__auto__ = [];\nvar len__4736__auto___49473 = arguments.length;\nvar i__4737__auto___49474 = (0);\nwhile(true){\nif((i__4737__auto___49474 < len__4736__auto___49473)){\nargs__4742__auto__.push((arguments[i__4737__auto___49474]));\n\nvar G__49475 = (i__4737__auto___49474 + (1));\ni__4737__auto___49474 = G__49475;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__4743__auto__ = ((((0) < args__4742__auto__.length))?(new cljs.core.IndexedSeq(args__4742__auto__.slice((0)),(0),null)):null);\nreturn re_frame.core.path.cljs$core$IFn$_invoke$arity$variadic(argseq__4743__auto__);\n});\n\n(re_frame.core.path.cljs$core$IFn$_invoke$arity$variadic = (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(re_frame.std_interceptors.path,args);\n}));\n\n(re_frame.core.path.cljs$lang$maxFixedArity = (0));\n\n/** @this {Function} */\n(re_frame.core.path.cljs$lang$applyTo = (function (seq49298){\nvar self__4724__auto__ = this;\nreturn self__4724__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq49298));\n}));\n\n/**\n * Returns an Interceptor which will run the given function `f` in the `:after`\n * position. \n * \n * `f` is called with two arguments: `db` and `v`, and is expected to\n * return a modified `db`.\n * \n * Unlike the `after` interceptor which is only about side effects, `enrich`\n * expects `f` to process and alter the given `db` coeffect in some useful way,\n * contributing to the derived data, flowing vibe.\n * \n * #### Example Use:\n * \n * Imagine that todomvc needed to do duplicate detection - if any two todos had\n * the same text, then highlight their background, and report them via a warning\n * at the bottom of the panel.\n * \n * Almost any user action (edit text, add new todo, remove a todo) requires a\n * complete reassessment of duplication errors and warnings. Eg: that edit\n * just made might have introduced a new duplicate, or removed one. Same with\n * any todo removal. So we need to re-calculate warnings after any CRUD events\n * associated with the todos list.\n * \n * Unless we are careful, we might end up coding subtly different checks\n * for each kind of CRUD operation. The duplicates check made after\n * 'delete todo' event might be subtly different to that done after an\n * editing operation. Nice and efficient, but fiddly. A bug generator\n * approach.\n * \n * So, instead, we create an `f` which recalculates ALL warnings from scratch\n * every time there is ANY change. It will inspect all the todos, and\n * reset ALL FLAGS every time (overwriting what was there previously)\n * and fully recalculate the list of duplicates (displayed at the bottom?).\n * \n * <a href=\"https://twitter.com/nathanmarz/status/879722740776939520\" target=\"_blank\">https://twitter.com/nathanmarz/status/879722740776939520</a>\n * \n * By applying `f` in an `:enrich` interceptor, after every CRUD event,\n * we keep the handlers simple and yet we ensure this important step\n * (of getting warnings right) is not missed on any change.\n * \n * We can test `f` easily - it is a pure function - independently of\n * any CRUD operation.\n * \n * This brings huge simplicity at the expense of some re-computation\n * each time. This may be a very satisfactory trade-off in many cases.\n */\nre_frame.core.enrich = (function re_frame$core$enrich(f){\nreturn re_frame.std_interceptors.enrich(f);\n});\n/**\n * An interceptor which removes the first element of the event vector,\n * before it is supplied to the event handler, allowing you to write more\n * aesthetically pleasing event handlers. No leading underscore on the event-v!\n * \n * Your event handlers will look like this:\n * \n * (reg-event-db\n * :event-id\n * [... trim-v ...] ;; <-- added to the interceptors\n * (fn [db [x y z]] ;; <-- instead of [_ x y z]\n * ...)\n * \n */\nre_frame.core.trim_v = re_frame.std_interceptors.trim_v;\n/**\n * Returns an interceptor which runs the given function `f` in the `:after`\n * position, presumably for side effects.\n * \n * `f` is called with two arguments: the `:effects` value for `:db`\n * (or the `:coeffect` value of `:db` if no `:db` effect is returned) and the event.\n * Its return value is ignored, so `f` can only side-effect.\n * \n * An example of use can be seen in the re-frame github repo in `/examples/todomvc/events.cljs`:\n * \n * - `f` runs schema validation (reporting any errors found).\n * - `f` writes to localstorage.\n */\nre_frame.core.after = (function re_frame$core$after(f){\nreturn re_frame.std_interceptors.after(f);\n});\n/**\n * Returns an interceptor which will observe N paths within `db`, and if any of them\n * test not identical? to their previous value (as a result of a event handler\n * being run), then it will run `f` to compute a new value, which is then assoc-ed\n * into the given `out-path` within `db`.\n * \n * Example Usage:\n * \n * (defn my-f\n * [a-val b-val]\n * ... some computation on a and b in here)\n * \n * ;; use it\n * (def my-interceptor (on-changes my-f [:c] [:a] [:b]))\n * \n * (reg-event-db\n * :event-id\n * [... my-interceptor ...] ;; <-- ultimately used here\n * (fn [db v]\n * ...))\n * \n * \n * If you put this Interceptor on handlers which might change paths `:a` or `:b`,\n * it will:\n * \n * - call `f` each time the value at path `[:a]` or `[:b]` changes\n * - call `f` with the values extracted from `[:a]` `[:b]`\n * - assoc the return value from `f` into the path `[:c]`\n * \n */\nre_frame.core.on_changes = (function re_frame$core$on_changes(var_args){\nvar args__4742__auto__ = [];\nvar len__4736__auto___49478 = arguments.length;\nvar i__4737__auto___49479 = (0);\nwhile(true){\nif((i__4737__auto___49479 < len__4736__auto___49478)){\nargs__4742__auto__.push((arguments[i__4737__auto___49479]));\n\nvar G__49480 = (i__4737__auto___49479 + (1));\ni__4737__auto___49479 = G__49480;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__4743__auto__ = ((((2) < args__4742__auto__.length))?(new cljs.core.IndexedSeq(args__4742__auto__.slice((2)),(0),null)):null);\nreturn re_frame.core.on_changes.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4743__auto__);\n});\n\n(re_frame.core.on_changes.cljs$core$IFn$_invoke$arity$variadic = (function (f,out_path,in_paths){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(re_frame.std_interceptors.on_changes,cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f,out_path], null),in_paths));\n}));\n\n(re_frame.core.on_changes.cljs$lang$maxFixedArity = (2));\n\n/** @this {Function} */\n(re_frame.core.on_changes.cljs$lang$applyTo = (function (seq49315){\nvar G__49316 = cljs.core.first(seq49315);\nvar seq49315__$1 = cljs.core.next(seq49315);\nvar G__49317 = cljs.core.first(seq49315__$1);\nvar seq49315__$2 = cljs.core.next(seq49315__$1);\nvar self__4723__auto__ = this;\nreturn self__4723__auto__.cljs$core$IFn$_invoke$arity$variadic(G__49316,G__49317,seq49315__$2);\n}));\n\n/**\n * Registers the given `interceptor` as a global interceptor. Global interceptors are\n * included in the processing chain of every event.\n * \n * When you register an event handler, you have the option of supplying an\n * interceptor chain. Any global interceptors you register are effectively\n * prepending to this chain.\n * \n * Global interceptors are run in the order that they are registered.\n */\nre_frame.core.reg_global_interceptor = (function re_frame$core$reg_global_interceptor(interceptor){\nreturn re_frame.settings.reg_global_interceptor(interceptor);\n});\n/**\n * Unregisters global interceptors (presumably registered previously via the use of `reg-global-interceptor`). \n * \n * When called with no args, it will unregister all currently registered global interceptors. \n * \n * When given one arg, assumed to be the `id` of a previously registered \n * global interceptors, it will unregister the associated interceptor. Will produce a warning to \n * console if it finds no matching registration.\n */\nre_frame.core.clear_global_interceptor = (function re_frame$core$clear_global_interceptor(var_args){\nvar G__49335 = arguments.length;\nswitch (G__49335) {\ncase 0:\nreturn re_frame.core.clear_global_interceptor.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn re_frame.core.clear_global_interceptor.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.clear_global_interceptor.cljs$core$IFn$_invoke$arity$0 = (function (){\nreturn re_frame.settings.clear_global_interceptors.cljs$core$IFn$_invoke$arity$0();\n}));\n\n(re_frame.core.clear_global_interceptor.cljs$core$IFn$_invoke$arity$1 = (function (id){\nreturn re_frame.settings.clear_global_interceptors.cljs$core$IFn$_invoke$arity$1(id);\n}));\n\n(re_frame.core.clear_global_interceptor.cljs$lang$maxFixedArity = 1);\n\n/**\n * A utility function for creating interceptors.\n * \n * Accepts three optional, named arguments:\n * \n * - `:id` - an id for the interceptor (decorative only)\n * - `:before` - the interceptor's before function\n * - `:after` - the interceptor's after function\n * \n * Example use:\n * \n * (def my-interceptor\n * (->interceptor\n * :id :my-interceptor\n * :before (fn [context]\n * ... modifies and returns `context`)\n * :after (fn [context] \n * ... modifies and returns `context`)))\n * \n * Notes:\n * \n * - `:before` functions modify and return their `context` argument. Sometimes they \n * only side effect, in which case, they'll perform the side effect and return\n * `context` unchanged.\n * - `:before` functions often modify the `:coeffects` map within `context` and, \n * if they do, then they should use the utility functions `get-coeffect` and \n * `assoc-coeffect`.\n * - `:after` functions modify and return their `context` argument. Sometimes they \n * only side effect, in which case, they'll perform the side effect and return \n * `context` unchanged.\n * - `:after` functions often modify the `:effects` map within `context` and, \n * if they do, then they should use the utility functions `get-effect`\n * and `assoc-effect`\n */\nre_frame.core.__GT_interceptor = (function re_frame$core$__GT_interceptor(var_args){\nvar args__4742__auto__ = [];\nvar len__4736__auto___49513 = arguments.length;\nvar i__4737__auto___49514 = (0);\nwhile(true){\nif((i__4737__auto___49514 < len__4736__auto___49513)){\nargs__4742__auto__.push((arguments[i__4737__auto___49514]));\n\nvar G__49518 = (i__4737__auto___49514 + (1));\ni__4737__auto___49514 = G__49518;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__4743__auto__ = ((((0) < args__4742__auto__.length))?(new cljs.core.IndexedSeq(args__4742__auto__.slice((0)),(0),null)):null);\nreturn re_frame.core.__GT_interceptor.cljs$core$IFn$_invoke$arity$variadic(argseq__4743__auto__);\n});\n\n(re_frame.core.__GT_interceptor.cljs$core$IFn$_invoke$arity$variadic = (function (p__49340){\nvar map__49341 = p__49340;\nvar map__49341__$1 = (((((!((map__49341 == null))))?(((((map__49341.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === map__49341.cljs$core$ISeq$))))?true:false):false))?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,map__49341):map__49341);\nvar m = map__49341__$1;\nvar id = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__49341__$1,new cljs.core.Keyword(null,\"id\",\"id\",-1388402092));\nvar before = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__49341__$1,new cljs.core.Keyword(null,\"before\",\"before\",-1633692388));\nvar after = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__49341__$1,new cljs.core.Keyword(null,\"after\",\"after\",594996914));\nreturn re_frame.utils.apply_kw.cljs$core$IFn$_invoke$arity$variadic(re_frame.interceptor.__GT_interceptor,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([m], 0));\n}));\n\n(re_frame.core.__GT_interceptor.cljs$lang$maxFixedArity = (0));\n\n/** @this {Function} */\n(re_frame.core.__GT_interceptor.cljs$lang$applyTo = (function (seq49338){\nvar self__4724__auto__ = this;\nreturn self__4724__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq49338));\n}));\n\n/**\n * A utility function, typically used when writing an interceptor's `:before` function.\n * \n * When called with one argument, it returns the `:coeffects` map from with that `context`.\n * \n * When called with two or three arguments, behaves like `clojure.core/get` and\n * returns the value mapped to `key` in the `:coeffects` map within `context`, `not-found` or\n * `nil` if `key` is not present.\n */\nre_frame.core.get_coeffect = (function re_frame$core$get_coeffect(var_args){\nvar G__49346 = arguments.length;\nswitch (G__49346) {\ncase 1:\nreturn re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$1 = (function (context){\nreturn re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$1(context);\n}));\n\n(re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$2 = (function (context,key){\nreturn re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$2(context,key);\n}));\n\n(re_frame.core.get_coeffect.cljs$core$IFn$_invoke$arity$3 = (function (context,key,not_found){\nreturn re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$3(context,key,not_found);\n}));\n\n(re_frame.core.get_coeffect.cljs$lang$maxFixedArity = 3);\n\n/**\n * A utility function, typically used when writing an interceptor's `:before` function.\n * \n * Adds or updates a key/value pair in the `:coeffects` map within `context`. \n */\nre_frame.core.assoc_coeffect = (function re_frame$core$assoc_coeffect(context,key,value){\nreturn re_frame.interceptor.assoc_coeffect(context,key,value);\n});\n/**\n * A utility function, used when writing interceptors, typically within an `:after` function.\n * \n * When called with one argument, returns the `:effects` map from the `context`.\n * \n * When called with two or three arguments, behaves like `clojure.core/get` and\n * returns the value mapped to `key` in the effects map, `not-found` or\n * `nil` if `key` is not present.\n */\nre_frame.core.get_effect = (function re_frame$core$get_effect(var_args){\nvar G__49362 = arguments.length;\nswitch (G__49362) {\ncase 1:\nreturn re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\"Invalid arity: \",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));\n\n}\n});\n\n(re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$1 = (function (context){\nreturn re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$1(context);\n}));\n\n(re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$2 = (function (context,key){\nreturn re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$2(context,key);\n}));\n\n(re_frame.core.get_effect.cljs$core$IFn$_invoke$arity$3 = (function (context,key,not_found){\nreturn re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$3(context,key,not_found);\n}));\n\n(re_frame.core.get_effect.cljs$lang$maxFixedArity = 3);\n\n/**\n * A utility function, typically used when writing an interceptor's `:after` function.\n * \n * Adds or updates a key/value pair in the `:effects` map within `context`. \n */\nre_frame.core.assoc_effect = (function re_frame$core$assoc_effect(context,key,value){\nreturn re_frame.interceptor.assoc_effect(context,key,value);\n});\n/**\n * A utility function, used when writing an interceptor's `:before` function.\n * \n * Adds the given collection of `interceptors` to those already in `context's` \n * execution `:queue`. It returns the updated `context`.\n * \n * So, it provides a way for one Interceptor to add more interceptors to the \n * currently executing interceptor chain.\n * \n */\nre_frame.core.enqueue = (function re_frame$core$enqueue(context,interceptors){\nreturn re_frame.interceptor.enqueue(context,interceptors);\n});\n/**\n * re-frame outputs warnings and errors via the API function `console` \n * which, by default, delegates to `js/console`'s default implementation for \n * `log`, `error`, `warn`, `debug`, `group` and `groupEnd`. But, using this function,\n * you can override that behaviour with your own functions. \n * \n * The argument `new-loggers` should be a map containing a subset of they keys \n * for the standard `loggers`, namely `:log` `:error` `:warn` `:debug` `:group` \n * or `:groupEnd`.\n * \n * Example Usage:\n * \n * (defn my-logger ;; my alternative logging function\n * [& args]\n * (post-it-somewhere (apply str args)))\n * \n * ;; now install my alternative loggers\n * (re-frame.core/set-loggers! {:warn my-logger :log my-logger})\n * \n */\nre_frame.core.set_loggers_BANG_ = (function re_frame$core$set_loggers_BANG_(new_loggers){\nreturn re_frame.loggers.set_loggers_BANG_(new_loggers);\n});\n/**\n * A utility logging function which is used internally within re-frame to produce \n * warnings and other output. It can also be used by libraries which \n * extend re-frame, such as effect handlers.\n * \n * By default, it will output the given `args` to `js/console` at the given log `level`.\n * However, an application using re-frame can redirect `console` output via `set-loggers!`. \n * \n * `level` can be one of `:log`, `:error`, `:warn`, `:debug`, `:group` or `:groupEnd`.\n * \n * Example usage:\n * \n * (console :error \"Sure enough it happened:\" a-var \"and\" another)\n * (console :warn \"Possible breach of containment wall at:\" dt)\n * \n */\nre_frame.core.console = (function re_frame$core$console(var_args){\nvar args__4742__auto__ = [];\nvar len__4736__auto___49546 = arguments.length;\nvar i__4737__auto___49547 = (0);\nwhile(true){\nif((i__4737__auto___49547 < len__4736__auto___49546)){\nargs__4742__auto__.push((arguments[i