simon/swinging-needle-meter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added compiled JavaScript to repository for GitHub pages

Browse source 
This feels like a mistake...
This commit is contained in:
Simon Brooke 2020-10-20 14:44:11 +01:00
parent 3d5a2fb322
commit dc226b1f25
468 changed files with 212152 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

68
resources/public/js/compiled/out/re_frame/cofx.cljc Normal file
View file

@ -0,0 +1,68 @@
(ns re-frame.cofx
(:require
[re-frame.db :refer [app-db]]
[re-frame.interceptor :refer [->interceptor]]
[re-frame.registrar :refer [get-handler clear-handlers register-handler]]
[re-frame.loggers :refer [console]]))
;; -- Registration ------------------------------------------------------------
(def kind :cofx)
(assert (re-frame.registrar/kinds kind))
(def register (partial register-handler kind))
;; -- Interceptor -------------------------------------------------------------
(defn inject-cofx
"Returns an interceptor which adds to a `context's` `:coeffects`.
`coeffects` are the input resources required by an event handler
to perform its job. The two most obvious ones are `db` and `event`.
But sometimes a handler might need other resources.
Perhaps a handler needs a random number or a GUID or the current datetime.
Perhaps it needs access to the connection to a DataScript database.
If the handler directly access these resources, it stops being as
pure. It immedaitely becomes harder to test, etc.
So the necessary resources are \"injected\" into the `coeffect` (map)
given the handler.
Given an `id`, and an optional value, lookup the registered coeffect
handler (previously registered via `reg-cofx`) and it with two arguments:
the current value of `:coeffects` and, optionally, the value. The registered handler
is expected to return a modified coeffect.
"
([id]
(->interceptor
:id :coeffects
:before (fn coeffects-before
[context]
(update context :coeffects (get-handler kind id)))))
([id value]
(->interceptor
:id :coeffects
:before (fn coeffects-before
[context]
(update context :coeffects (get-handler kind id) value)))))
;; -- Builtin CoEffects Handlers ---------------------------------------------
;; :db
;;
;; Adds to coeffects the value in `app-db`, under the key `:db`
(register
:db
(fn db-coeffects-handler
[coeffects]
(assoc coeffects :db @app-db)))
;; Because this interceptor is used so much, we reify it
(def inject-db (inject-cofx :db))

1
resources/public/js/compiled/out/re_frame/cofx.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {console re-frame.loggers}, :excludes #{}, :name re-frame.cofx, :imports nil, :requires {re-frame.db re-frame.db, re-frame.interceptor re-frame.interceptor, re-frame.registrar re-frame.registrar, re-frame.loggers re-frame.loggers}, :uses {console re-frame.loggers, app-db re-frame.db, ->interceptor re-frame.interceptor, get-handler re-frame.registrar, clear-handlers re-frame.registrar, register-handler re-frame.registrar}, :defs {kind {:name re-frame.cofx/kind, :file "docs/js/compiled/out/re_frame/cofx.cljc", :line 11, :column 1, :end-line 11, :end-column 10, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/cofx.cljc", :line 11, :column 6, :end-line 11, :end-column 10}}, register {:name re-frame.cofx/register, :file "docs/js/compiled/out/re_frame/cofx.cljc", :line 13, :column 1, :end-line 13, :end-column 14, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/cofx.cljc", :line 13, :column 6, :end-line 13, :end-column 14}}, inject-cofx {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/cofx.cljc", :line 18, :column 7, :end-line 18, :end-column 18, :arglists (quote ([id] [id value])), :doc "Returns an interceptor which adds to a `context's` `:coeffects`.\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 a handler might need other resources.\n\n Perhaps a handler needs a random number or a GUID or the current datetime.\n Perhaps it needs access to the connection to a DataScript database.\n\n If the handler directly access these resources, it stops being as\n pure. It immedaitely becomes harder to test, etc.\n\n So the necessary resources are \"injected\" into the `coeffect` (map)\n given the handler.\n\n Given an `id`, and an optional value, lookup the registered coeffect\n handler (previously registered via `reg-cofx`) and it with two arguments:\n the current value of `:coeffects` and, optionally, the value. The registered handler\n is expected to return a modified coeffect.\n ", :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([id] [id value]), :arglists ([id] [id value]), :arglists-meta (nil nil)}}, :name re-frame.cofx/inject-cofx, :variadic false, :file "docs/js/compiled/out/re_frame/cofx.cljc", :end-column 18, :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([id] [id value]), :arglists ([id] [id value]), :arglists-meta (nil nil)}, :method-params ([id] [id value]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 18, :end-line 18, :max-fixed-arity 2, :fn-var true, :arglists ([id] [id value]), :doc "Returns an interceptor which adds to a `context's` `:coeffects`.\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 a handler might need other resources.\n\n Perhaps a handler needs a random number or a GUID or the current datetime.\n Perhaps it needs access to the connection to a DataScript database.\n\n If the handler directly access these resources, it stops being as\n pure. It immedaitely becomes harder to test, etc.\n\n So the necessary resources are \"injected\" into the `coeffect` (map)\n given the handler.\n\n Given an `id`, and an optional value, lookup the registered coeffect\n handler (previously registered via `reg-cofx`) and it with two arguments:\n the current value of `:coeffects` and, optionally, the value. The registered handler\n is expected to return a modified coeffect.\n "}, inject-db {:name re-frame.cofx/inject-db, :file "docs/js/compiled/out/re_frame/cofx.cljc", :line 66, :column 1, :end-line 66, :end-column 15, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/cofx.cljc", :line 66, :column 6, :end-line 66, :end-column 15}}}, :require-macros nil, :cljs.analyzer/constants {:seen #{:db :id :coeffects :cofx :before}, :order [:cofx :id :coeffects :before :db]}, :doc nil}

87
resources/public/js/compiled/out/re_frame/cofx.js Normal file
View file

@ -0,0 +1,87 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.cofx');
goog.require('cljs.core');
goog.require('re_frame.db');
goog.require('re_frame.interceptor');
goog.require('re_frame.registrar');
goog.require('re_frame.loggers');
re_frame.cofx.kind = new cljs.core.Keyword(null,"cofx","cofx",2013202907);
if(cljs.core.truth_(re_frame.registrar.kinds.call(null,re_frame.cofx.kind))){
} else {
throw (new Error("Assert failed: (re-frame.registrar/kinds kind)"));
}
re_frame.cofx.register = cljs.core.partial.call(null,re_frame.registrar.register_handler,re_frame.cofx.kind);
/**
* Returns an interceptor which adds to a `context's` `:coeffects`.
*
* `coeffects` are the input resources required by an event handler
* to perform its job. The two most obvious ones are `db` and `event`.
* But sometimes a handler might need other resources.
*
* Perhaps a handler needs a random number or a GUID or the current datetime.
* Perhaps it needs access to the connection to a DataScript database.
*
* If the handler directly access these resources, it stops being as
* pure. It immedaitely becomes harder to test, etc.
*
* So the necessary resources are "injected" into the `coeffect` (map)
* given the handler.
*
* Given an `id`, and an optional value, lookup the registered coeffect
* handler (previously registered via `reg-cofx`) and it with two arguments:
* the current value of `:coeffects` and, optionally, the value. The registered handler
* is expected to return a modified coeffect.
*
*/
re_frame.cofx.inject_cofx = (function re_frame$cofx$inject_cofx(var_args){
var args32997 = [];
var len__26205__auto___33000 = arguments.length;
var i__26206__auto___33001 = (0);
while(true){
if((i__26206__auto___33001 < len__26205__auto___33000)){
args32997.push((arguments[i__26206__auto___33001]));
var G__33002 = (i__26206__auto___33001 + (1));
i__26206__auto___33001 = G__33002;
continue;
} else {
}
break;
}
var G__32999 = args32997.length;
switch (G__32999) {
case 1:
return re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32997.length)].join('')));
}
});
re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$1 = (function (id){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$cofx$coeffects_before(context){
return cljs.core.update.call(null,context,new cljs.core.Keyword(null,"coeffects","coeffects",497912985),re_frame.registrar.get_handler.call(null,re_frame.cofx.kind,id));
}));
});
re_frame.cofx.inject_cofx.cljs$core$IFn$_invoke$arity$2 = (function (id,value){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$cofx$coeffects_before(context){
return cljs.core.update.call(null,context,new cljs.core.Keyword(null,"coeffects","coeffects",497912985),re_frame.registrar.get_handler.call(null,re_frame.cofx.kind,id),value);
}));
});
re_frame.cofx.inject_cofx.cljs$lang$maxFixedArity = 2;
re_frame.cofx.register.call(null,new cljs.core.Keyword(null,"db","db",993250759),(function re_frame$cofx$db_coeffects_handler(coeffects){
return cljs.core.assoc.call(null,coeffects,new cljs.core.Keyword(null,"db","db",993250759),cljs.core.deref.call(null,re_frame.db.app_db));
}));
re_frame.cofx.inject_db = re_frame.cofx.inject_cofx.call(null,new cljs.core.Keyword(null,"db","db",993250759));
//# sourceMappingURL=cofx.js.map?rel=1603199198178

1
resources/public/js/compiled/out/re_frame/cofx.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/cofx.js","sources":["cofx.cljc?rel=1603199198179"],"lineCount":87,"mappings":";AAAA;;;;;;AAUA,qBAAA,rBAAKA;AACL,oBAAQ,AAACE,mCAAyBF;AAAlC;AAAA,AAAA,MAAA,KAAAC,MAAA;;AACA,AAAKE,yBAAU,AAACC,4BAAQC,oCAAiBL;AAKzC,AAAA;;;;;;;;;;;;;;;;;;;;;;4BAAA,oCAAAM,hEAAMK;AAAN,AAAA,IAAAJ,YAAA;AAAA,AAAA,IAAAC,2BAAA,AAAA;AAAA,AAAA,IAAAC,yBAAA;;AAAA,AAAA,GAAA,CAAAA,yBAAAD;AAAA,AAAA,AAAAD,eAAA,CAAA,UAAAE;;AAAA,eAAA,CAAAA,yBAAA;;;;AAAA;;;;AAAA,IAAAC,WAAA,AAAAH;AAAA,AAAA,QAAAG;KAAA;AAAA,OAAAC,wDAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,wDAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;;AAAA,MAAA,KAAAV,MAAA,eAAA,iCAAA,AAAAM;;;;;AAAA,AAAA,0DAAA,1DAAMI,qEAqBFC;AArBJ,AAsBE,uDAAA,kDAAA,8DAAA,hKAACC,0NAEU,yCACGC;AADH,AAEE,0CAAA,nCAACC,2BAAOD,sEAAmB,AAACE,yCAAYhB,mBAAKY;;;;AA1B5D,AAAA,0DAAA,1DAAMD,qEA2BFC,GAAGK;AA3BP,AA4BG,uDAAA,kDAAA,8DAAA,hKAACJ,0NAEU,yCACGC;AADH,AAEE,0CAAA,nCAACC,2BAAOD,sEAAmB,AAACE,yCAAYhB,mBAAKY,IAAIK;;;;AAhCjE,AAAA,oDAAA,pDAAMN;;AAAN,AAwCA,iCAAA,jCAACR,iFAEC,6CACGe;AADH,AAEE,2CAAA,gDAAA,AAAAC,pFAACC,0BAAMF,oFAAeG;;AAI1B,AAAKC,0BAAU,oCAAA,pCAACX","names":["re-frame.cofx\/kind","js\/Error","re-frame.registrar\/kinds","re-frame.cofx\/register","cljs.core\/partial","re-frame.registrar\/register-handler","var_args","args32997","len__26205__auto__","i__26206__auto__","G__32999","re-frame.cofx\/inject-cofx","id","re-frame.interceptor\/->interceptor","context","cljs.core\/update","re-frame.registrar\/get-handler","value","coeffects","cljs.core\/deref","cljs.core\/assoc","re-frame.db\/app-db","re-frame.cofx\/inject-db"]}

189
resources/public/js/compiled/out/re_frame/core.cljc Normal file
View file

@ -0,0 +1,189 @@
(ns re-frame.core
(:require
[re-frame.events :as events]
[re-frame.subs :as subs]
[re-frame.interop :as interop]
[re-frame.db :as db]
[re-frame.fx :as fx]
[re-frame.cofx :as cofx]
[re-frame.router :as router]
[re-frame.loggers :as loggers]
[re-frame.registrar :as registrar]
[re-frame.interceptor :as interceptor]
[re-frame.std-interceptors :as std-interceptors :refer [db-handler->interceptor
fx-handler->interceptor
ctx-handler->interceptor]]
[clojure.set :as set]))
;; -- dispatch
(def dispatch router/dispatch)
(def dispatch-sync router/dispatch-sync)
;; XXX move API functions up to this core level - to enable code completion and docs
;; XXX on figwheel reload, is there a way to not get the re-registration messages.
;; -- interceptor related
;; useful if you are writing your own interceptors
(def ->interceptor interceptor/->interceptor)
(def enqueue interceptor/enqueue)
(def get-coeffect interceptor/get-coeffect)
(def get-effect interceptor/get-effect)
(def assoc-effect interceptor/assoc-effect)
(def assoc-coeffect interceptor/assoc-coeffect)
;; -- standard interceptors
(def debug std-interceptors/debug)
(def path std-interceptors/path)
(def enrich std-interceptors/enrich)
(def trim-v std-interceptors/trim-v)
(def after std-interceptors/after)
(def on-changes std-interceptors/on-changes)
;; -- subscriptions
(defn reg-sub-raw
"Associate a given `query id` with a given subscription handler function `handler-fn`
which is expected to take two arguments: app-db and query vector, and return
a `reaction`.
This is a low level, advanced function. You should probably be using reg-sub
instead."
[query-id handler-fn]
(registrar/register-handler subs/kind query-id handler-fn))
(def reg-sub subs/reg-sub)
(def subscribe subs/subscribe)
(def clear-sub (partial registrar/clear-handlers subs/kind))
(def clear-subscription-cache! subs/clear-subscription-cache!)
;; -- effects
(def reg-fx fx/register)
(def clear-fx (partial registrar/clear-handlers fx/kind))
;; -- coeffects
(def reg-cofx cofx/register)
(def inject-cofx cofx/inject-cofx)
(def clear-cofx (partial registrar/clear-handlers cofx/kind))
;; -- Events
(def clear-event (partial registrar/clear-handlers events/kind))
(defn reg-event-db
"Register the given `id`, typically a keyword, with the combination of
`db-handler` and an interceptor chain.
`db-handler` is a function: (db event) -> db
`interceptors` is a collection of interceptors, possibly nested (needs flattening).
`db-handler` is wrapped in an interceptor and added to the end of the chain, so in the end
there is only a chain.
The necessary effects and coeffects handler are added to the front of the
interceptor chain. These interceptors ensure that app-db is available and updated."
([id db-handler]
(reg-event-db id nil db-handler))
([id interceptors db-handler]
(events/register id [cofx/inject-db fx/do-fx interceptors (db-handler->interceptor db-handler)])))
(defn reg-event-fx
([id fx-handler]
(reg-event-fx id nil fx-handler))
([id interceptors fx-handler]
(events/register id [cofx/inject-db fx/do-fx interceptors (fx-handler->interceptor fx-handler)])))
(defn reg-event-ctx
([id handler]
(reg-event-ctx id nil handler))
([id interceptors handler]
(events/register id [cofx/inject-db fx/do-fx interceptors (ctx-handler->interceptor handler)])))
;; -- Logging -----
;; Internally, re-frame uses the logging functions: warn, log, error, group and groupEnd
;; By default, these functions map directly to the js/console implementations,
;; but you can override with your own fns (set or subset).
;; Example Usage:
;; (defn my-fn [& args] (post-it-somewhere (apply str args))) ;; here is my alternative
;; (re-frame.core/set-loggers! {:warn my-fn :log my-fn}) ;; override the defaults with mine
(def set-loggers! loggers/set-loggers!)
;; If you are writing an extension to re-frame, like perhaps
;; an effects handler, you may want to use re-frame logging.
;;
;; usage: (console :error "this is bad: " a-variable " and " anotherv)
;; (console :warn "possible breach of containment wall at: " dt)
(def console loggers/console)
;; -- State Restoration For Unit Tests
(defn make-restore-fn
"Checkpoints the state of re-frame and returns a function which, when
later called, will restore re-frame to that checkpointed state.
Checkpoint includes app-db, all registered handlers and all subscriptions.
"
[]
(let [handlers @registrar/kind->id->handler
app-db @db/app-db
subs-cache @subs/query->reaction]
(fn []
;; call `dispose!` on all current subscriptions which
;; didn't originally exist.
(let [original-subs (set (vals subs-cache))
current-subs (set (vals @subs/query->reaction))]
(doseq [sub (set/difference current-subs original-subs)]
(interop/dispose! sub)))
;; Reset the atoms
;; We don't need to reset subs/query->reaction, as
;; disposing of the subs removes them from the cache anyway
(reset! registrar/kind->id->handler handlers)
(reset! db/app-db app-db)
nil)))
;; -- Event Processing Callbacks
(defn add-post-event-callback
"Registers a function `f` to be called after each event is processed
`f` will be called with two arguments:
- `event`: a vector. The event just processed.
- `queue`: a PersistentQueue, possibly empty, of events yet to be processed.
This is useful in advanced cases like:
- you are implementing a complex bootstrap pipeline
- you want to create your own handling infrastructure, with perhaps multiple
handlers for the one event, etc. Hook in here.
- libraries providing 'isomorphic javascript' rendering on Nodejs or Nashorn.
'id' is typically a keyword. Supplied at \"add time\" so it can subsequently
be used at \"remove time\" to get rid of the right callback.
"
([f]
(add-post-event-callback f f)) ;; use f as its own identifier
([id f]
(router/add-post-event-callback re-frame.router/event-queue id f)))
(defn remove-post-event-callback
[id]
(router/remove-post-event-callback re-frame.router/event-queue id))
;; -- Deprecation Messages
;; Assisting the v0.0.7 -> v0.0.8 transition.
(defn register-handler
[& args]
(console :warn "re-frame: \"register-handler\" has been renamed \"reg-event-db\" (look for registration of " (str (first args)) ")")
(apply reg-event-db args))
(defn register-sub
[& args]
(console :warn "re-frame: \"register-sub\" is deprecated. Use \"reg-sub-raw\" (look for registration of " (str (first args)) ")")
(apply reg-sub-raw args))

1
resources/public/js/compiled/out/re_frame/core.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

391
resources/public/js/compiled/out/re_frame/core.js Normal file
View file

@ -0,0 +1,391 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.core');
goog.require('cljs.core');
goog.require('re_frame.interop');
goog.require('re_frame.subs');
goog.require('clojure.set');
goog.require('re_frame.cofx');
goog.require('re_frame.interceptor');
goog.require('re_frame.fx');
goog.require('re_frame.events');
goog.require('re_frame.loggers');
goog.require('re_frame.registrar');
goog.require('re_frame.router');
goog.require('re_frame.db');
goog.require('re_frame.std_interceptors');
re_frame.core.dispatch = re_frame.router.dispatch;
re_frame.core.dispatch_sync = re_frame.router.dispatch_sync;
re_frame.core.__GT_interceptor = re_frame.interceptor.__GT_interceptor;
re_frame.core.enqueue = re_frame.interceptor.enqueue;
re_frame.core.get_coeffect = re_frame.interceptor.get_coeffect;
re_frame.core.get_effect = re_frame.interceptor.get_effect;
re_frame.core.assoc_effect = re_frame.interceptor.assoc_effect;
re_frame.core.assoc_coeffect = re_frame.interceptor.assoc_coeffect;
re_frame.core.debug = re_frame.std_interceptors.debug;
re_frame.core.path = re_frame.std_interceptors.path;
re_frame.core.enrich = re_frame.std_interceptors.enrich;
re_frame.core.trim_v = re_frame.std_interceptors.trim_v;
re_frame.core.after = re_frame.std_interceptors.after;
re_frame.core.on_changes = re_frame.std_interceptors.on_changes;
/**
* Associate a given `query id` with a given subscription handler function `handler-fn`
* which is expected to take two arguments: app-db and query vector, and return
* a `reaction`.
*
* This is a low level, advanced function. You should probably be using reg-sub
* instead.
*/
re_frame.core.reg_sub_raw = (function re_frame$core$reg_sub_raw(query_id,handler_fn){
return re_frame.registrar.register_handler.call(null,re_frame.subs.kind,query_id,handler_fn);
});
re_frame.core.reg_sub = re_frame.subs.reg_sub;
re_frame.core.subscribe = re_frame.subs.subscribe;
re_frame.core.clear_sub = cljs.core.partial.call(null,re_frame.registrar.clear_handlers,re_frame.subs.kind);
re_frame.core.clear_subscription_cache_BANG_ = re_frame.subs.clear_subscription_cache_BANG_;
re_frame.core.reg_fx = re_frame.fx.register;
re_frame.core.clear_fx = cljs.core.partial.call(null,re_frame.registrar.clear_handlers,re_frame.fx.kind);
re_frame.core.reg_cofx = re_frame.cofx.register;
re_frame.core.inject_cofx = re_frame.cofx.inject_cofx;
re_frame.core.clear_cofx = cljs.core.partial.call(null,re_frame.registrar.clear_handlers,re_frame.cofx.kind);
re_frame.core.clear_event = cljs.core.partial.call(null,re_frame.registrar.clear_handlers,re_frame.events.kind);
/**
* Register the given `id`, typically a keyword, with the combination of
* `db-handler` and an interceptor chain.
* `db-handler` is a function: (db event) -> db
* `interceptors` is a collection of interceptors, possibly nested (needs flattening).
* `db-handler` is wrapped in an interceptor and added to the end of the chain, so in the end
* there is only a chain.
* The necessary effects and coeffects handler are added to the front of the
* interceptor chain. These interceptors ensure that app-db is available and updated.
*/
re_frame.core.reg_event_db = (function re_frame$core$reg_event_db(var_args){
var args33421 = [];
var len__26205__auto___33424 = arguments.length;
var i__26206__auto___33425 = (0);
while(true){
if((i__26206__auto___33425 < len__26205__auto___33424)){
args33421.push((arguments[i__26206__auto___33425]));
var G__33426 = (i__26206__auto___33425 + (1));
i__26206__auto___33425 = G__33426;
continue;
} else {
}
break;
}
var G__33423 = args33421.length;
switch (G__33423) {
case 2:
return re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args33421.length)].join('')));
}
});
re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$2 = (function (id,db_handler){
return re_frame.core.reg_event_db.call(null,id,null,db_handler);
});
re_frame.core.reg_event_db.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,db_handler){
return re_frame.events.register.call(null,id,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,interceptors,re_frame.std_interceptors.db_handler__GT_interceptor.call(null,db_handler)], null));
});
re_frame.core.reg_event_db.cljs$lang$maxFixedArity = 3;
re_frame.core.reg_event_fx = (function re_frame$core$reg_event_fx(var_args){
var args33428 = [];
var len__26205__auto___33431 = arguments.length;
var i__26206__auto___33432 = (0);
while(true){
if((i__26206__auto___33432 < len__26205__auto___33431)){
args33428.push((arguments[i__26206__auto___33432]));
var G__33433 = (i__26206__auto___33432 + (1));
i__26206__auto___33432 = G__33433;
continue;
} else {
}
break;
}
var G__33430 = args33428.length;
switch (G__33430) {
case 2:
return re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args33428.length)].join('')));
}
});
re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$2 = (function (id,fx_handler){
return re_frame.core.reg_event_fx.call(null,id,null,fx_handler);
});
re_frame.core.reg_event_fx.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,fx_handler){
return re_frame.events.register.call(null,id,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,interceptors,re_frame.std_interceptors.fx_handler__GT_interceptor.call(null,fx_handler)], null));
});
re_frame.core.reg_event_fx.cljs$lang$maxFixedArity = 3;
re_frame.core.reg_event_ctx = (function re_frame$core$reg_event_ctx(var_args){
var args33435 = [];
var len__26205__auto___33438 = arguments.length;
var i__26206__auto___33439 = (0);
while(true){
if((i__26206__auto___33439 < len__26205__auto___33438)){
args33435.push((arguments[i__26206__auto___33439]));
var G__33440 = (i__26206__auto___33439 + (1));
i__26206__auto___33439 = G__33440;
continue;
} else {
}
break;
}
var G__33437 = args33435.length;
switch (G__33437) {
case 2:
return re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args33435.length)].join('')));
}
});
re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$2 = (function (id,handler){
return re_frame.core.reg_event_ctx.call(null,id,null,handler);
});
re_frame.core.reg_event_ctx.cljs$core$IFn$_invoke$arity$3 = (function (id,interceptors,handler){
return re_frame.events.register.call(null,id,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [re_frame.cofx.inject_db,re_frame.fx.do_fx,interceptors,re_frame.std_interceptors.ctx_handler__GT_interceptor.call(null,handler)], null));
});
re_frame.core.reg_event_ctx.cljs$lang$maxFixedArity = 3;
re_frame.core.set_loggers_BANG_ = re_frame.loggers.set_loggers_BANG_;
re_frame.core.console = re_frame.loggers.console;
/**
* Checkpoints the state of re-frame and returns a function which, when
* later called, will restore re-frame to that checkpointed state.
*
* Checkpoint includes app-db, all registered handlers and all subscriptions.
*
*/
re_frame.core.make_restore_fn = (function re_frame$core$make_restore_fn(){
var handlers = cljs.core.deref.call(null,re_frame.registrar.kind__GT_id__GT_handler);
var app_db = cljs.core.deref.call(null,re_frame.db.app_db);
var subs_cache = cljs.core.deref.call(null,re_frame.subs.query__GT_reaction);
return ((function (handlers,app_db,subs_cache){
return (function (){
var original_subs_33450 = cljs.core.set.call(null,cljs.core.vals.call(null,subs_cache));
var current_subs_33451 = cljs.core.set.call(null,cljs.core.vals.call(null,cljs.core.deref.call(null,re_frame.subs.query__GT_reaction)));
var seq__33446_33452 = cljs.core.seq.call(null,clojure.set.difference.call(null,current_subs_33451,original_subs_33450));
var chunk__33447_33453 = null;
var count__33448_33454 = (0);
var i__33449_33455 = (0);
while(true){
if((i__33449_33455 < count__33448_33454)){
var sub_33456 = cljs.core._nth.call(null,chunk__33447_33453,i__33449_33455);
re_frame.interop.dispose_BANG_.call(null,sub_33456);
var G__33457 = seq__33446_33452;
var G__33458 = chunk__33447_33453;
var G__33459 = count__33448_33454;
var G__33460 = (i__33449_33455 + (1));
seq__33446_33452 = G__33457;
chunk__33447_33453 = G__33458;
count__33448_33454 = G__33459;
i__33449_33455 = G__33460;
continue;
} else {
var temp__4657__auto___33461 = cljs.core.seq.call(null,seq__33446_33452);
if(temp__4657__auto___33461){
var seq__33446_33462__$1 = temp__4657__auto___33461;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__33446_33462__$1)){
var c__25941__auto___33463 = cljs.core.chunk_first.call(null,seq__33446_33462__$1);
var G__33464 = cljs.core.chunk_rest.call(null,seq__33446_33462__$1);
var G__33465 = c__25941__auto___33463;
var G__33466 = cljs.core.count.call(null,c__25941__auto___33463);
var G__33467 = (0);
seq__33446_33452 = G__33464;
chunk__33447_33453 = G__33465;
count__33448_33454 = G__33466;
i__33449_33455 = G__33467;
continue;
} else {
var sub_33468 = cljs.core.first.call(null,seq__33446_33462__$1);
re_frame.interop.dispose_BANG_.call(null,sub_33468);
var G__33469 = cljs.core.next.call(null,seq__33446_33462__$1);
var G__33470 = null;
var G__33471 = (0);
var G__33472 = (0);
seq__33446_33452 = G__33469;
chunk__33447_33453 = G__33470;
count__33448_33454 = G__33471;
i__33449_33455 = G__33472;
continue;
}
} else {
}
}
break;
}
cljs.core.reset_BANG_.call(null,re_frame.registrar.kind__GT_id__GT_handler,handlers);
cljs.core.reset_BANG_.call(null,re_frame.db.app_db,app_db);
return null;
});
;})(handlers,app_db,subs_cache))
});
/**
* Registers a function `f` to be called after each event is processed
* `f` will be called with two arguments:
* - `event`: a vector. The event just processed.
* - `queue`: a PersistentQueue, possibly empty, of events yet to be processed.
*
* This is useful in advanced cases like:
* - you are implementing a complex bootstrap pipeline
* - you want to create your own handling infrastructure, with perhaps multiple
* handlers for the one event, etc. Hook in here.
* - libraries providing 'isomorphic javascript' rendering on Nodejs or Nashorn.
*
* 'id' is typically a keyword. Supplied at "add time" so it can subsequently
* be used at "remove time" to get rid of the right callback.
*
*/
re_frame.core.add_post_event_callback = (function re_frame$core$add_post_event_callback(var_args){
var args33473 = [];
var len__26205__auto___33476 = arguments.length;
var i__26206__auto___33477 = (0);
while(true){
if((i__26206__auto___33477 < len__26205__auto___33476)){
args33473.push((arguments[i__26206__auto___33477]));
var G__33478 = (i__26206__auto___33477 + (1));
i__26206__auto___33477 = G__33478;
continue;
} else {
}
break;
}
var G__33475 = args33473.length;
switch (G__33475) {
case 1:
return re_frame.core.add_post_event_callback.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.core.add_post_event_callback.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args33473.length)].join('')));
}
});
re_frame.core.add_post_event_callback.cljs$core$IFn$_invoke$arity$1 = (function (f){
return re_frame.core.add_post_event_callback.call(null,f,f);
});
re_frame.core.add_post_event_callback.cljs$core$IFn$_invoke$arity$2 = (function (id,f){
return re_frame.router.add_post_event_callback.call(null,re_frame.router.event_queue,id,f);
});
re_frame.core.add_post_event_callback.cljs$lang$maxFixedArity = 2;
re_frame.core.remove_post_event_callback = (function re_frame$core$remove_post_event_callback(id){
return re_frame.router.remove_post_event_callback.call(null,re_frame.router.event_queue,id);
});
re_frame.core.register_handler = (function re_frame$core$register_handler(var_args){
var args__26212__auto__ = [];
var len__26205__auto___33481 = arguments.length;
var i__26206__auto___33482 = (0);
while(true){
if((i__26206__auto___33482 < len__26205__auto___33481)){
args__26212__auto__.push((arguments[i__26206__auto___33482]));
var G__33483 = (i__26206__auto___33482 + (1));
i__26206__auto___33482 = G__33483;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((0) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((0)),(0),null)):null);
return re_frame.core.register_handler.cljs$core$IFn$_invoke$arity$variadic(argseq__26213__auto__);
});
re_frame.core.register_handler.cljs$core$IFn$_invoke$arity$variadic = (function (args){
re_frame.core.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: \"register-handler\" has been renamed \"reg-event-db\" (look for registration of ",[cljs.core.str(cljs.core.first.call(null,args))].join(''),")");
return cljs.core.apply.call(null,re_frame.core.reg_event_db,args);
});
re_frame.core.register_handler.cljs$lang$maxFixedArity = (0);
re_frame.core.register_handler.cljs$lang$applyTo = (function (seq33480){
return re_frame.core.register_handler.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq33480));
});
re_frame.core.register_sub = (function re_frame$core$register_sub(var_args){
var args__26212__auto__ = [];
var len__26205__auto___33485 = arguments.length;
var i__26206__auto___33486 = (0);
while(true){
if((i__26206__auto___33486 < len__26205__auto___33485)){
args__26212__auto__.push((arguments[i__26206__auto___33486]));
var G__33487 = (i__26206__auto___33486 + (1));
i__26206__auto___33486 = G__33487;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((0) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((0)),(0),null)):null);
return re_frame.core.register_sub.cljs$core$IFn$_invoke$arity$variadic(argseq__26213__auto__);
});
re_frame.core.register_sub.cljs$core$IFn$_invoke$arity$variadic = (function (args){
re_frame.core.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: \"register-sub\" is deprecated. Use \"reg-sub-raw\" (look for registration of ",[cljs.core.str(cljs.core.first.call(null,args))].join(''),")");
return cljs.core.apply.call(null,re_frame.core.reg_sub_raw,args);
});
re_frame.core.register_sub.cljs$lang$maxFixedArity = (0);
re_frame.core.register_sub.cljs$lang$applyTo = (function (seq33484){
return re_frame.core.register_sub.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq33484));
});
//# sourceMappingURL=core.js.map?rel=1603199198801

1
resources/public/js/compiled/out/re_frame/core.js.map Normal file
View file

File diff suppressed because one or more lines are too long

11
resources/public/js/compiled/out/re_frame/db.cljc Normal file
View file

@ -0,0 +1,11 @@
(ns re-frame.db
(:require [re-frame.interop :refer [ratom]]))
;; -- Application State --------------------------------------------------------------------------
;;
;; Should not be accessed directly by application code.
;; Read access goes through subscriptions.
;; Updates via event handlers.
(def app-db (ratom {}))

1
resources/public/js/compiled/out/re_frame/db.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {ratom re-frame.interop}, :excludes #{}, :name re-frame.db, :imports nil, :requires {re-frame.interop re-frame.interop}, :uses {ratom re-frame.interop}, :defs {app-db {:name re-frame.db/app-db, :file "docs/js/compiled/out/re_frame/db.cljc", :line 10, :column 1, :end-line 10, :end-column 12, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/db.cljc", :line 10, :column 6, :end-line 10, :end-column 12}}}, :require-macros nil, :doc nil}

7
resources/public/js/compiled/out/re_frame/db.js Normal file
View file

@ -0,0 +1,7 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.db');
goog.require('cljs.core');
goog.require('re_frame.interop');
re_frame.db.app_db = re_frame.interop.ratom.call(null,cljs.core.PersistentArrayMap.EMPTY);
//# sourceMappingURL=db.js.map?rel=1603199197702

1
resources/public/js/compiled/out/re_frame/db.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/db.js","sources":["db.cljc?rel=1603199197702"],"lineCount":7,"mappings":";AAAA;;;AASA,AAAKA,qBAAO,iCAAA,jCAACC","names":["re-frame.db\/app-db","re-frame.interop\/ratom"]}

65
resources/public/js/compiled/out/re_frame/events.cljc Normal file
View file

@ -0,0 +1,65 @@
(ns re-frame.events
(:require [re-frame.db :refer [app-db]]
[re-frame.utils :refer [first-in-vector]]
[re-frame.interop :refer [empty-queue debug-enabled?]]
[re-frame.registrar :refer [get-handler register-handler]]
[re-frame.loggers :refer [console]]
[re-frame.interceptor :as interceptor]
[re-frame.trace :as trace :include-macros true]))
(def kind :event)
(assert (re-frame.registrar/kinds kind))
(defn- flatten-and-remove-nils
"`interceptors` might have nested collections, and contain nil elements.
return a flat collection, with all nils removed.
This function is 9/10 about giving good error messages"
[id interceptors]
(let [make-chain #(->> % flatten (remove nil?))]
(if-not debug-enabled?
(make-chain interceptors)
(do ;; do a whole lot of development time checks
(when-not (coll? interceptors)
(console :error (str "re-frame: when registering " id ", expected a collection of interceptors, got:") interceptors))
(let [chain (make-chain interceptors)]
(when (empty? chain)
(console :error (str "re-frame: when registering" id ", given an empty interceptor chain")))
(when-let [not-i (first (remove interceptor/interceptor? chain))]
(if (fn? not-i)
(console :error (str "re-frame: when registering " id ", got a function instead of an interceptor. Did you provide old style middleware by mistake? Got:") not-i)
(console :error (str "re-frame: when registering " id ", expected interceptors, but got:") not-i)))
chain)))))
(defn register
"Associate the given event `id` with the given collection of `interceptors`.
`interceptors` may contain nested collections and there may be nils
at any level,so process this structure into a simple, nil-less vector
before registration.
An `event handler` will likely be at the end of the chain (wrapped in an interceptor)."
[id interceptors]
(register-handler kind id (flatten-and-remove-nils id interceptors)))
;; -- handle event --------------------------------------------------------------------------------
(def ^:dynamic *handling* nil) ;; remember what event we are currently handling
(defn handle
"Given an event vector, look up the associated intercepter chain, and execute it."
[event-v]
(let [event-id (first-in-vector event-v)]
(if-let [interceptors (get-handler kind event-id true)]
(if *handling*
(console :error (str "re-frame: while handling \"" *handling* "\", dispatch-sync was called for \"" event-v "\". You can't call dispatch-sync within an event handler."))
(binding [*handling* event-v]
(trace/with-trace {:operation event-id
:op-type kind
:tags {:event event-v}}
(interceptor/execute event-v interceptors)))))))

1
resources/public/js/compiled/out/re_frame/events.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {console re-frame.loggers, empty-queue re-frame.interop, debug-enabled? re-frame.interop}, :excludes #{}, :name re-frame.events, :imports nil, :requires {re-frame.db re-frame.db, re-frame.utils re-frame.utils, re-frame.interop re-frame.interop, re-frame.registrar re-frame.registrar, re-frame.loggers re-frame.loggers, interceptor re-frame.interceptor, re-frame.interceptor re-frame.interceptor, trace re-frame.trace, re-frame.trace re-frame.trace}, :uses {console re-frame.loggers, app-db re-frame.db, get-handler re-frame.registrar, first-in-vector re-frame.utils, empty-queue re-frame.interop, debug-enabled? re-frame.interop, register-handler re-frame.registrar}, :defs {kind {:name re-frame.events/kind, :file "docs/js/compiled/out/re_frame/events.cljc", :line 11, :column 1, :end-line 11, :end-column 10, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/events.cljc", :line 11, :column 6, :end-line 11, :end-column 10}}, flatten-and-remove-nils {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/events.cljc", :line 14, :column 8, :end-line 14, :end-column 31, :private true, :arglists (quote ([id interceptors])), :doc "`interceptors` might have nested collections, and contain nil elements.\n return a flat collection, with all nils removed.\n This function is 9/10 about giving good error messages"}, :private true, :name re-frame.events/flatten-and-remove-nils, :variadic false, :file "docs/js/compiled/out/re_frame/events.cljc", :end-column 31, :method-params ([id interceptors]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 14, :end-line 14, :max-fixed-arity 2, :fn-var true, :arglists (quote ([id interceptors])), :doc "`interceptors` might have nested collections, and contain nil elements.\n return a flat collection, with all nils removed.\n This function is 9/10 about giving good error messages"}, register {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/events.cljc", :line 35, :column 7, :end-line 35, :end-column 15, :arglists (quote ([id interceptors])), :doc "Associate the given event `id` with the given collection of `interceptors`.\n\n `interceptors` may contain nested collections and there may be nils\n at any level,so process this structure into a simple, nil-less vector\n before registration.\n\n An `event handler` will likely be at the end of the chain (wrapped in an interceptor)."}, :name re-frame.events/register, :variadic false, :file "docs/js/compiled/out/re_frame/events.cljc", :end-column 15, :method-params ([id interceptors]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 35, :end-line 35, :max-fixed-arity 2, :fn-var true, :arglists (quote ([id interceptors])), :doc "Associate the given event `id` with the given collection of `interceptors`.\n\n `interceptors` may contain nested collections and there may be nils\n at any level,so process this structure into a simple, nil-less vector\n before registration.\n\n An `event handler` will likely be at the end of the chain (wrapped in an interceptor)."}, *handling* {:name re-frame.events/*handling*, :file "docs/js/compiled/out/re_frame/events.cljc", :line 50, :column 1, :end-line 50, :end-column 26, :dynamic true, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/events.cljc", :line 50, :column 16, :end-line 50, :end-column 26, :dynamic true}}, handle {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/events.cljc", :line 52, :column 7, :end-line 52, :end-column 13, :arglists (quote ([event-v])), :doc "Given an event vector, look up the associated intercepter chain, and execute it."}, :name re-frame.events/handle, :variadic false, :file "docs/js/compiled/out/re_frame/events.cljc", :end-column 13, :method-params ([event-v]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 52, :end-line 52, :max-fixed-arity 1, :fn-var true, :arglists (quote ([event-v])), :doc "Given an event vector, look up the associated intercepter chain, and execute it."}}, :require-macros {trace re-frame.trace, re-frame.trace re-frame.trace}, :cljs.analyzer/constants {:seen #{:tags :else :operation :start :duration :event :error :end :op-type}, :order [:event :error :operation :op-type :tags :start :else :duration :end]}, :doc nil}

171
resources/public/js/compiled/out/re_frame/events.js Normal file
View file

@ -0,0 +1,171 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.events');
goog.require('cljs.core');
goog.require('re_frame.db');
goog.require('re_frame.utils');
goog.require('re_frame.interop');
goog.require('re_frame.registrar');
goog.require('re_frame.loggers');
goog.require('re_frame.interceptor');
goog.require('re_frame.trace');
re_frame.events.kind = new cljs.core.Keyword(null,"event","event",301435442);
if(cljs.core.truth_(re_frame.registrar.kinds.call(null,re_frame.events.kind))){
} else {
throw (new Error("Assert failed: (re-frame.registrar/kinds kind)"));
}
/**
* `interceptors` might have nested collections, and contain nil elements.
* return a flat collection, with all nils removed.
* This function is 9/10 about giving good error messages
*/
re_frame.events.flatten_and_remove_nils = (function re_frame$events$flatten_and_remove_nils(id,interceptors){
var make_chain = (function (p1__32773_SHARP_){
return cljs.core.remove.call(null,cljs.core.nil_QMARK_,cljs.core.flatten.call(null,p1__32773_SHARP_));
});
if(!(re_frame.interop.debug_enabled_QMARK_)){
return make_chain.call(null,interceptors);
} else {
if(cljs.core.coll_QMARK_.call(null,interceptors)){
} else {
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),[cljs.core.str("re-frame: when registering "),cljs.core.str(id),cljs.core.str(", expected a collection of interceptors, got:")].join(''),interceptors);
}
var chain = make_chain.call(null,interceptors);
if(cljs.core.empty_QMARK_.call(null,chain)){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),[cljs.core.str("re-frame: when registering"),cljs.core.str(id),cljs.core.str(", given an empty interceptor chain")].join(''));
} else {
}
var temp__4657__auto___32774 = cljs.core.first.call(null,cljs.core.remove.call(null,re_frame.interceptor.interceptor_QMARK_,chain));
if(cljs.core.truth_(temp__4657__auto___32774)){
var not_i_32775 = temp__4657__auto___32774;
if(cljs.core.fn_QMARK_.call(null,not_i_32775)){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),[cljs.core.str("re-frame: when registering "),cljs.core.str(id),cljs.core.str(", got a function instead of an interceptor. Did you provide old style middleware by mistake? Got:")].join(''),not_i_32775);
} else {
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),[cljs.core.str("re-frame: when registering "),cljs.core.str(id),cljs.core.str(", expected interceptors, but got:")].join(''),not_i_32775);
}
} else {
}
return chain;
}
});
/**
* Associate the given event `id` with the given collection of `interceptors`.
*
* `interceptors` may contain nested collections and there may be nils
* at any level,so process this structure into a simple, nil-less vector
* before registration.
*
* An `event handler` will likely be at the end of the chain (wrapped in an interceptor).
*/
re_frame.events.register = (function re_frame$events$register(id,interceptors){
return re_frame.registrar.register_handler.call(null,re_frame.events.kind,id,re_frame.events.flatten_and_remove_nils.call(null,id,interceptors));
});
re_frame.events._STAR_handling_STAR_ = null;
/**
* Given an event vector, look up the associated intercepter chain, and execute it.
*/
re_frame.events.handle = (function re_frame$events$handle(event_v){
var event_id = re_frame.utils.first_in_vector.call(null,event_v);
var temp__4655__auto__ = re_frame.registrar.get_handler.call(null,re_frame.events.kind,event_id,true);
if(cljs.core.truth_(temp__4655__auto__)){
var interceptors = temp__4655__auto__;
if(cljs.core.truth_(re_frame.events._STAR_handling_STAR_)){
return re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),[cljs.core.str("re-frame: while handling \""),cljs.core.str(re_frame.events._STAR_handling_STAR_),cljs.core.str("\", dispatch-sync was called for \""),cljs.core.str(event_v),cljs.core.str("\". You can't call dispatch-sync within an event handler.")].join(''));
} else {
var _STAR_handling_STAR_32790 = re_frame.events._STAR_handling_STAR_;
re_frame.events._STAR_handling_STAR_ = event_v;
try{if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var _STAR_current_trace_STAR_32791 = re_frame.trace._STAR_current_trace_STAR_;
re_frame.trace._STAR_current_trace_STAR_ = re_frame.trace.start_trace.call(null,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"operation","operation",-1267664310),event_id,new cljs.core.Keyword(null,"op-type","op-type",-1636141668),re_frame.events.kind,new cljs.core.Keyword(null,"tags","tags",1771418977),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"event","event",301435442),event_v], null)], null));
try{try{return re_frame.interceptor.execute.call(null,event_v,interceptors);
}finally {if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var end__32708__auto___32804 = re_frame.interop.now.call(null);
var duration__32709__auto___32805 = (end__32708__auto___32804 - new cljs.core.Keyword(null,"start","start",-355208981).cljs$core$IFn$_invoke$arity$1(re_frame.trace._STAR_current_trace_STAR_));
var seq__32792_32806 = cljs.core.seq.call(null,cljs.core.deref.call(null,re_frame.trace.trace_cbs));
var chunk__32793_32807 = null;
var count__32794_32808 = (0);
var i__32795_32809 = (0);
while(true){
if((i__32795_32809 < count__32794_32808)){
var vec__32796_32810 = cljs.core._nth.call(null,chunk__32793_32807,i__32795_32809);
var k__32710__auto___32811 = cljs.core.nth.call(null,vec__32796_32810,(0),null);
var cb__32711__auto___32812 = cljs.core.nth.call(null,vec__32796_32810,(1),null);
try{cb__32711__auto___32812.call(null,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.assoc.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"duration","duration",1444101068),duration__32709__auto___32805,new cljs.core.Keyword(null,"end","end",-268185958),re_frame.interop.now.call(null))], null));
}catch (e32799){if((e32799 instanceof java.lang.Exception)){
var e__32712__auto___32813 = e32799;
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"Error thrown from trace cb",k__32710__auto___32811,"while storing",re_frame.trace._STAR_current_trace_STAR_,e__32712__auto___32813);
} else {
throw e32799;
}
}
var G__32814 = seq__32792_32806;
var G__32815 = chunk__32793_32807;
var G__32816 = count__32794_32808;
var G__32817 = (i__32795_32809 + (1));
seq__32792_32806 = G__32814;
chunk__32793_32807 = G__32815;
count__32794_32808 = G__32816;
i__32795_32809 = G__32817;
continue;
} else {
var temp__4657__auto___32818 = cljs.core.seq.call(null,seq__32792_32806);
if(temp__4657__auto___32818){
var seq__32792_32819__$1 = temp__4657__auto___32818;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32792_32819__$1)){
var c__25941__auto___32820 = cljs.core.chunk_first.call(null,seq__32792_32819__$1);
var G__32821 = cljs.core.chunk_rest.call(null,seq__32792_32819__$1);
var G__32822 = c__25941__auto___32820;
var G__32823 = cljs.core.count.call(null,c__25941__auto___32820);
var G__32824 = (0);
seq__32792_32806 = G__32821;
chunk__32793_32807 = G__32822;
count__32794_32808 = G__32823;
i__32795_32809 = G__32824;
continue;
} else {
var vec__32800_32825 = cljs.core.first.call(null,seq__32792_32819__$1);
var k__32710__auto___32826 = cljs.core.nth.call(null,vec__32800_32825,(0),null);
var cb__32711__auto___32827 = cljs.core.nth.call(null,vec__32800_32825,(1),null);
try{cb__32711__auto___32827.call(null,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.assoc.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"duration","duration",1444101068),duration__32709__auto___32805,new cljs.core.Keyword(null,"end","end",-268185958),re_frame.interop.now.call(null))], null));
}catch (e32803){if((e32803 instanceof java.lang.Exception)){
var e__32712__auto___32828 = e32803;
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"Error thrown from trace cb",k__32710__auto___32826,"while storing",re_frame.trace._STAR_current_trace_STAR_,e__32712__auto___32828);
} else {
throw e32803;
}
}
var G__32829 = cljs.core.next.call(null,seq__32792_32819__$1);
var G__32830 = null;
var G__32831 = (0);
var G__32832 = (0);
seq__32792_32806 = G__32829;
chunk__32793_32807 = G__32830;
count__32794_32808 = G__32831;
i__32795_32809 = G__32832;
continue;
}
} else {
}
}
break;
}
} else {
}
}}finally {re_frame.trace._STAR_current_trace_STAR_ = _STAR_current_trace_STAR_32791;
}} else {
return re_frame.interceptor.execute.call(null,event_v,interceptors);
}
}finally {re_frame.events._STAR_handling_STAR_ = _STAR_handling_STAR_32790;
}}
} else {
return null;
}
});
//# sourceMappingURL=events.js.map?rel=1603199197772

1
resources/public/js/compiled/out/re_frame/events.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/events.js","sources":["events.cljc?rel=1603199197773"],"lineCount":171,"mappings":";AAAA;;;;;;;;;AAUA,uBAAA,vBAAKA;AACL,oBAAQ,AAACE,mCAAyBF;AAAlC;AAAA,AAAA,MAAA,KAAAC,MAAA;;AAEA;;;;;0CAAA,1CAAOE,4FAIJC,GAAGC;AAJN,AAKE,iBAAA,WAAAC,xBAAMC;AAAN,uDAA0BC,vDAAQ,uDAAA,4BAAAF,5EAACG,2BAAOC;;AAA1C,AACE,GAAA,EAAQC;AACN,OAACJ,qBAAWF;;AACZ,AACE,GAAU,AAACO,gCAAMP;AAAjB;AAAA,AACE,mCAAA,nCAACQ,0FAAe,eAAA,+DAAA,lBAAmCT,6EAAoDC;;;AACzG,IAAMS,QAAM,AAACP,qBAAWF;AAAxB,AACE,GAAM,AAACU,iCAAOD;AAAd,AACE,mCAAA,nCAACD,0FAAe,eAAA,8DAAA,lBAAkCT;;AADpD;;AAEA,IAAAY,2BAAiB,AAACE,0BAAM,AAACT,2BAAOU,wCAAyBL;AAAzD,AAAA,oBAAAE;AAAA,AAAA,kBAAAA,dAAWC;AAAX,AACE,GAAI,AAACG,8BAAIH;AACP,mCAAA,nCAACJ,0FAAe,eAAA,+DAAA,lBAAmCT,iIAAwGa;;AAC3J,mCAAA,nCAACJ,0FAAe,eAAA,+DAAA,lBAAmCT,iEAAwCa;;;AAH\/F;;AAIAH;;;AAGV;;;;;;;;;2BAAA,3BAAMO,8DAQHjB,GAAGC;AARN,AASE,OAACiB,8CAAiBtB,qBAAKI,GAAG,AAACD,kDAAwBC,GAAGC;;AAMxD,uCAAA,vCAAekB;AAEf;;;yBAAA,zBAAMC,0DAEHC;AAFH,AAGE,IAAMC,WAAU,AAACC,yCAAgBF;AAAjC,AACE,IAAAG,qBAAuB,uEAAA,vEAACC,yCAAY7B,qBAAK0B;AAAzC,AAAA,oBAAAE;AAAA,mBAAAA,fAASvB;AAAT,AACE,oBAAIkB;AACF,0CAAA,nCAACV,0FAAe,eAAA,iGAAA,4EAAA,hIAAmCU,yGAAiDE;;AACpG,IAAAK,4BAAUP;AAAV,AAAA,AAAUA,uCAAYE;;AAAtB,IAAA,AACE,GAAA,AAAAM;AAAA,IAAAC,iCAAAC;AAAA,AAAA,AAAAA,2CAAA,AAAAC,qCAAA,2CAAA,yEAAA,iFAAA,qDAAA,2CAAA,1LAA8BR,qEACA1B,2KACQyB;;AAFtC,IAAA,AAAA,IAAA,AAGE,OAACqC,uCAAoBrC,QAAQpB;UAH\/B,AAAA,GAAA,AAAA0B;AAAA,AAAA,IAAAI,2BAAA,AAAAC;IAAAC,gCAAA,CAAAF,2BAAA,AAAA,qFAAAF;AAAA,AAAA,IAAAK,mBAAA,AAAAC,wBAAA,AAAAC,0BAAAC;IAAAC,qBAAA;IAAAC,qBAAA;IAAAC,iBAAA;;AAAA,AAAA,GAAA,AAAA,CAAAA,iBAAAD;AAAA,IAAAE,mBAAA,AAAAC,yBAAAJ,mBAAAE;IAAAG,yBAAA,AAAAC,wBAAAH,iBAAA,IAAA;IAAAI,0BAAA,AAAAD,wBAAAH,iBAAA,IAAA;AAAA,AAAA,AAAA,IAAA,AAAA,AAAAI,kCAAA,mFAAA,AAAAC,0BAAAjB,yCAAA,6DAAAI,8BAAA,mDAAA,AAAAD;gBAAA,GAAA,CAAAe,kBAAAC;AAAA,IAAAC,yBAAAF;AAAA,AAAA,AAAAtC,mCAAA,uDAAA,6BAAAkC,uBAAA,gBAAAd,yCAAAoB;;AAAA,AAAA,MAAAF;;;;AAAA,eAAAb;eAAAI;eAAAC;eAAA,CAAAC,iBAAA;;;;;;;AAAA,IAAA5B,2BAAA,AAAAuB,wBAAAD;AAAA,AAAA,GAAAtB;AAAA,AAAA,IAAAsB,uBAAAtB;AAAA,AAAA,GAAA,AAAAsC,uCAAAhB;AAAA,IAAAiB,yBAAA,AAAAC,gCAAAlB;AAAA,AAAA,eAAA,AAAAmB,+BAAAnB;eAAAiB;eAAA,AAAAG,0BAAAH;eAAA;;;;;;;AAAA,IAAAI,mBAAA,AAAAzC,0BAAAoB;IAAAS,yBAAA,AAAAC,wBAAAW,iBAAA,IAAA;IAAAV,0BAAA,AAAAD,wBAAAW,iBAAA,IAAA;AAAA,AAAA,AAAA,IAAA,AAAA,AAAAV,kCAAA,mFAAA,AAAAC,0BAAAjB,yCAAA,6DAAAI,8BAAA,mDAAA,AAAAD;gBAAA,GAAA,CAAAwB,kBAAAR;AAAA,IAAAC,yBAAAO;AAAA,AAAA,AAAA\/C,mCAAA,uDAAA,6BAAAkC,uBAAA,gBAAAd,yCAAAoB;;AAAA,AAAA,MAAAO;;;;AAAA,eAAA,AAAAC,yBAAAvB;eAAA;eAAA;eAAA;;;;;;;;AAAA;;;;;AAAA;WAAA,AAAA,AAAAL,2CAAAD;;AAAA,AAGE,OAAC8B,uCAAoBrC,QAAQpB;;UAJjC,AAAA,uCAAAyB,vCAAUP;;;AAHd","names":["re-frame.events\/kind","js\/Error","re-frame.registrar\/kinds","re-frame.events\/flatten-and-remove-nils","id","interceptors","p1__32773#","make-chain","cljs.core\/flatten","cljs.core\/remove","cljs.core\/nil?","re-frame.interop\/debug-enabled?","cljs.core\/coll?","re-frame.loggers\/console","chain","cljs.core\/empty?","temp__4657__auto__","not-i","cljs.core\/first","re-frame.interceptor\/interceptor?","cljs.core\/fn?","re-frame.events\/register","re-frame.registrar\/register-handler","re-frame.events\/*handling*","re-frame.events\/handle","event-v","event-id","re-frame.utils\/first-in-vector","temp__4655__auto__","re-frame.registrar\/get-handler","*handling*32790","re-frame.trace\/is-trace-enabled?","*current-trace*32791","re-frame.trace\/*current-trace*","re-frame.trace\/start-trace","end__32708__auto__","re-frame.interop\/now","duration__32709__auto__","seq__32792","cljs.core\/seq","cljs.core\/deref","re-frame.trace\/trace-cbs","chunk__32793","count__32794","i__32795","vec__32796","cljs.core\/-nth","k__32710__auto__","cljs.core\/nth","cb__32711__auto__","cljs.core\/assoc","e32799","java\/lang.Exception","e__32712__auto__","cljs.core\/chunked-seq?","c__25941__auto__","cljs.core\/chunk-first","cljs.core\/chunk-rest","cljs.core\/count","vec__32800","e32803","cljs.core\/next","re-frame.interceptor\/execute"]}

122
resources/public/js/compiled/out/re_frame/fx.cljc Normal file
View file

@ -0,0 +1,122 @@
(ns re-frame.fx
(:require
[re-frame.router :as router]
[re-frame.db :refer [app-db]]
[re-frame.interceptor :refer [->interceptor]]
[re-frame.interop :refer [set-timeout!]]
[re-frame.events :as events]
[re-frame.registrar :refer [get-handler clear-handlers register-handler]]
[re-frame.loggers :refer [console]]))
;; -- Registration ------------------------------------------------------------
(def kind :fx)
(assert (re-frame.registrar/kinds kind))
(def register (partial register-handler kind))
;; -- Interceptor -------------------------------------------------------------
(def do-fx
"An interceptor which actions a `context's` (side) `:effects`.
For each key in the `:effects` map, call the `effects handler` previously
registered using `reg-fx`.
So, if `:effects` was:
{:dispatch [:hello 42]
:db {...}
:undo \"set flag\"}
call the registered effects handlers for each of the map's keys:
`:dispatch`, `:undo` and `:db`."
(->interceptor
:id :do-fx
:after (fn do-fx-after
[context]
(doseq [[effect-k value] (:effects context)]
(if-let [effect-fn (get-handler kind effect-k true)]
(effect-fn value))))))
;; -- Builtin Effect Handlers ------------------------------------------------
;; :dispatch-later
;;
;; `dispatch` one or more events after given delays. Expects a collection
;; of maps with two keys: :`ms` and `:dispatch`
;;
;; usage:
;;
;; {:dispatch-later [{:ms 200 :dispatch [:event-id "param"]} ;; in 200ms do this: (dispatch [:event-id "param"])
;; {:ms 100 :dispatch [:also :this :in :100ms]}]}
;;
(register
:dispatch-later
(fn [value]
(doseq [{:keys [ms dispatch] :as effect} value]
(if (or (empty? dispatch) (not (number? ms)))
(console :error "re-frame: ignoring bad :dispatch-later value:" effect)
(set-timeout! #(router/dispatch dispatch) ms)))))
;; :dispatch
;;
;; `dispatch` one event. Excepts a single vector.
;;
;; usage:
;; {:dispatch [:event-id "param"] }
(register
:dispatch
(fn [value]
(if-not (vector? value)
(console :error "re-frame: ignoring bad :dispatch value. Expected a vector, but got:" value)
(router/dispatch value))))
;; :dispatch-n
;;
;; `dispatch` more than one event. Expects a list or vector of events. Something for which
;; sequential? returns true.
;;
;; usage:
;; {:dispatch-n (list [:do :all] [:three :of] [:these])}
;;
(register
:dispatch-n
(fn [value]
(if-not (sequential? value)
(console :error "re-frame: ignoring bad :dispatch-n value. Expected a collection, got got:" value))
(doseq [event value] (router/dispatch event))))
;; :deregister-event-handler
;;
;; removes a previously registered event handler. Expects either a single id (
;; typically a keyword), or a seq of ids.
;;
;; usage:
;; {:deregister-event-handler :my-id)}
;; or:
;; {:deregister-event-handler [:one-id :another-id]}
;;
(register
:deregister-event-handler
(fn [value]
(let [clear-event (partial clear-handlers events/kind)]
(if (sequential? value)
(doseq [event (if (sequential? value) value [value])]
(clear-event event))))))
;; :db
;;
;; reset! app-db with a new value. Expects a map.
;;
;; usage:
;; {:db {:key1 value1 key2 value2}}
;;
(register
:db
(fn [value]
(reset! app-db value)))

1
resources/public/js/compiled/out/re_frame/fx.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {console re-frame.loggers, set-timeout! re-frame.interop}, :excludes #{}, :name re-frame.fx, :imports nil, :requires {router re-frame.router, re-frame.router re-frame.router, re-frame.db re-frame.db, re-frame.interceptor re-frame.interceptor, re-frame.interop re-frame.interop, events re-frame.events, re-frame.events re-frame.events, re-frame.registrar re-frame.registrar, re-frame.loggers re-frame.loggers}, :uses {console re-frame.loggers, app-db re-frame.db, ->interceptor re-frame.interceptor, set-timeout! re-frame.interop, get-handler re-frame.registrar, clear-handlers re-frame.registrar, register-handler re-frame.registrar}, :defs {kind {:name re-frame.fx/kind, :file "docs/js/compiled/out/re_frame/fx.cljc", :line 14, :column 1, :end-line 14, :end-column 10, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/fx.cljc", :line 14, :column 6, :end-line 14, :end-column 10}}, register {:name re-frame.fx/register, :file "docs/js/compiled/out/re_frame/fx.cljc", :line 16, :column 1, :end-line 16, :end-column 14, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/fx.cljc", :line 16, :column 6, :end-line 16, :end-column 14}}, do-fx {:name re-frame.fx/do-fx, :file "docs/js/compiled/out/re_frame/fx.cljc", :line 20, :column 1, :end-line 20, :end-column 11, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/fx.cljc", :line 20, :column 6, :end-line 20, :end-column 11}, :doc "An interceptor which actions a `context's` (side) `:effects`.\n\n For each key in the `:effects` map, call the `effects handler` previously\n registered using `reg-fx`.\n\n So, if `:effects` was:\n {:dispatch [:hello 42]\n :db {...}\n :undo \"set flag\"}\n call the registered effects handlers for each of the map's keys:\n `:dispatch`, `:undo` and `:db`."}}, :require-macros nil, :cljs.analyzer/constants {:seen #{:db :do-fx :dispatch-n :deregister-event-handler :dispatch :after :id :effects :error :ms :fx :dispatch-later}, :order [:fx :id :do-fx :after :effects :dispatch-later :ms :dispatch :error :dispatch-n :deregister-event-handler :db]}, :doc nil}

309
resources/public/js/compiled/out/re_frame/fx.js Normal file
View file

@ -0,0 +1,309 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.fx');
goog.require('cljs.core');
goog.require('re_frame.router');
goog.require('re_frame.db');
goog.require('re_frame.interceptor');
goog.require('re_frame.interop');
goog.require('re_frame.events');
goog.require('re_frame.registrar');
goog.require('re_frame.loggers');
re_frame.fx.kind = new cljs.core.Keyword(null,"fx","fx",-1237829572);
if(cljs.core.truth_(re_frame.registrar.kinds.call(null,re_frame.fx.kind))){
} else {
throw (new Error("Assert failed: (re-frame.registrar/kinds kind)"));
}
re_frame.fx.register = cljs.core.partial.call(null,re_frame.registrar.register_handler,re_frame.fx.kind);
/**
* An interceptor which actions a `context's` (side) `:effects`.
*
* For each key in the `:effects` map, call the `effects handler` previously
* registered using `reg-fx`.
*
* So, if `:effects` was:
* {:dispatch [:hello 42]
* :db {...}
* :undo "set flag"}
* call the registered effects handlers for each of the map's keys:
* `:dispatch`, `:undo` and `:db`.
*/
re_frame.fx.do_fx = re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"do-fx","do-fx",1194163050),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$fx$do_fx_after(context){
var seq__32917 = cljs.core.seq.call(null,new cljs.core.Keyword(null,"effects","effects",-282369292).cljs$core$IFn$_invoke$arity$1(context));
var chunk__32918 = null;
var count__32919 = (0);
var i__32920 = (0);
while(true){
if((i__32920 < count__32919)){
var vec__32921 = cljs.core._nth.call(null,chunk__32918,i__32920);
var effect_k = cljs.core.nth.call(null,vec__32921,(0),null);
var value = cljs.core.nth.call(null,vec__32921,(1),null);
var temp__4655__auto___32927 = re_frame.registrar.get_handler.call(null,re_frame.fx.kind,effect_k,true);
if(cljs.core.truth_(temp__4655__auto___32927)){
var effect_fn_32928 = temp__4655__auto___32927;
effect_fn_32928.call(null,value);
} else {
}
var G__32929 = seq__32917;
var G__32930 = chunk__32918;
var G__32931 = count__32919;
var G__32932 = (i__32920 + (1));
seq__32917 = G__32929;
chunk__32918 = G__32930;
count__32919 = G__32931;
i__32920 = G__32932;
continue;
} else {
var temp__4657__auto__ = cljs.core.seq.call(null,seq__32917);
if(temp__4657__auto__){
var seq__32917__$1 = temp__4657__auto__;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32917__$1)){
var c__25941__auto__ = cljs.core.chunk_first.call(null,seq__32917__$1);
var G__32933 = cljs.core.chunk_rest.call(null,seq__32917__$1);
var G__32934 = c__25941__auto__;
var G__32935 = cljs.core.count.call(null,c__25941__auto__);
var G__32936 = (0);
seq__32917 = G__32933;
chunk__32918 = G__32934;
count__32919 = G__32935;
i__32920 = G__32936;
continue;
} else {
var vec__32924 = cljs.core.first.call(null,seq__32917__$1);
var effect_k = cljs.core.nth.call(null,vec__32924,(0),null);
var value = cljs.core.nth.call(null,vec__32924,(1),null);
var temp__4655__auto___32937 = re_frame.registrar.get_handler.call(null,re_frame.fx.kind,effect_k,true);
if(cljs.core.truth_(temp__4655__auto___32937)){
var effect_fn_32938 = temp__4655__auto___32937;
effect_fn_32938.call(null,value);
} else {
}
var G__32939 = cljs.core.next.call(null,seq__32917__$1);
var G__32940 = null;
var G__32941 = (0);
var G__32942 = (0);
seq__32917 = G__32939;
chunk__32918 = G__32940;
count__32919 = G__32941;
i__32920 = G__32942;
continue;
}
} else {
return null;
}
}
break;
}
}));
re_frame.fx.register.call(null,new cljs.core.Keyword(null,"dispatch-later","dispatch-later",291951390),(function (value){
var seq__32943 = cljs.core.seq.call(null,value);
var chunk__32944 = null;
var count__32945 = (0);
var i__32946 = (0);
while(true){
if((i__32946 < count__32945)){
var map__32947 = cljs.core._nth.call(null,chunk__32944,i__32946);
var map__32947__$1 = ((((!((map__32947 == null)))?((((map__32947.cljs$lang$protocol_mask$partition0$ & (64))) || (map__32947.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__32947):map__32947);
var effect = map__32947__$1;
var ms = cljs.core.get.call(null,map__32947__$1,new cljs.core.Keyword(null,"ms","ms",-1152709733));
var dispatch = cljs.core.get.call(null,map__32947__$1,new cljs.core.Keyword(null,"dispatch","dispatch",1319337009));
if((cljs.core.empty_QMARK_.call(null,dispatch)) || (!(typeof ms === 'number'))){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: ignoring bad :dispatch-later value:",effect);
} else {
re_frame.interop.set_timeout_BANG_.call(null,((function (seq__32943,chunk__32944,count__32945,i__32946,map__32947,map__32947__$1,effect,ms,dispatch){
return (function (){
return re_frame.router.dispatch.call(null,dispatch);
});})(seq__32943,chunk__32944,count__32945,i__32946,map__32947,map__32947__$1,effect,ms,dispatch))
,ms);
}
var G__32951 = seq__32943;
var G__32952 = chunk__32944;
var G__32953 = count__32945;
var G__32954 = (i__32946 + (1));
seq__32943 = G__32951;
chunk__32944 = G__32952;
count__32945 = G__32953;
i__32946 = G__32954;
continue;
} else {
var temp__4657__auto__ = cljs.core.seq.call(null,seq__32943);
if(temp__4657__auto__){
var seq__32943__$1 = temp__4657__auto__;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32943__$1)){
var c__25941__auto__ = cljs.core.chunk_first.call(null,seq__32943__$1);
var G__32955 = cljs.core.chunk_rest.call(null,seq__32943__$1);
var G__32956 = c__25941__auto__;
var G__32957 = cljs.core.count.call(null,c__25941__auto__);
var G__32958 = (0);
seq__32943 = G__32955;
chunk__32944 = G__32956;
count__32945 = G__32957;
i__32946 = G__32958;
continue;
} else {
var map__32949 = cljs.core.first.call(null,seq__32943__$1);
var map__32949__$1 = ((((!((map__32949 == null)))?((((map__32949.cljs$lang$protocol_mask$partition0$ & (64))) || (map__32949.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__32949):map__32949);
var effect = map__32949__$1;
var ms = cljs.core.get.call(null,map__32949__$1,new cljs.core.Keyword(null,"ms","ms",-1152709733));
var dispatch = cljs.core.get.call(null,map__32949__$1,new cljs.core.Keyword(null,"dispatch","dispatch",1319337009));
if((cljs.core.empty_QMARK_.call(null,dispatch)) || (!(typeof ms === 'number'))){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: ignoring bad :dispatch-later value:",effect);
} else {
re_frame.interop.set_timeout_BANG_.call(null,((function (seq__32943,chunk__32944,count__32945,i__32946,map__32949,map__32949__$1,effect,ms,dispatch,seq__32943__$1,temp__4657__auto__){
return (function (){
return re_frame.router.dispatch.call(null,dispatch);
});})(seq__32943,chunk__32944,count__32945,i__32946,map__32949,map__32949__$1,effect,ms,dispatch,seq__32943__$1,temp__4657__auto__))
,ms);
}
var G__32959 = cljs.core.next.call(null,seq__32943__$1);
var G__32960 = null;
var G__32961 = (0);
var G__32962 = (0);
seq__32943 = G__32959;
chunk__32944 = G__32960;
count__32945 = G__32961;
i__32946 = G__32962;
continue;
}
} else {
return null;
}
}
break;
}
}));
re_frame.fx.register.call(null,new cljs.core.Keyword(null,"dispatch","dispatch",1319337009),(function (value){
if(!(cljs.core.vector_QMARK_.call(null,value))){
return re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: ignoring bad :dispatch value. Expected a vector, but got:",value);
} else {
return re_frame.router.dispatch.call(null,value);
}
}));
re_frame.fx.register.call(null,new cljs.core.Keyword(null,"dispatch-n","dispatch-n",-504469236),(function (value){
if(!(cljs.core.sequential_QMARK_.call(null,value))){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: ignoring bad :dispatch-n value. Expected a collection, got got:",value);
} else {
}
var seq__32963 = cljs.core.seq.call(null,value);
var chunk__32964 = null;
var count__32965 = (0);
var i__32966 = (0);
while(true){
if((i__32966 < count__32965)){
var event = cljs.core._nth.call(null,chunk__32964,i__32966);
re_frame.router.dispatch.call(null,event);
var G__32967 = seq__32963;
var G__32968 = chunk__32964;
var G__32969 = count__32965;
var G__32970 = (i__32966 + (1));
seq__32963 = G__32967;
chunk__32964 = G__32968;
count__32965 = G__32969;
i__32966 = G__32970;
continue;
} else {
var temp__4657__auto__ = cljs.core.seq.call(null,seq__32963);
if(temp__4657__auto__){
var seq__32963__$1 = temp__4657__auto__;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32963__$1)){
var c__25941__auto__ = cljs.core.chunk_first.call(null,seq__32963__$1);
var G__32971 = cljs.core.chunk_rest.call(null,seq__32963__$1);
var G__32972 = c__25941__auto__;
var G__32973 = cljs.core.count.call(null,c__25941__auto__);
var G__32974 = (0);
seq__32963 = G__32971;
chunk__32964 = G__32972;
count__32965 = G__32973;
i__32966 = G__32974;
continue;
} else {
var event = cljs.core.first.call(null,seq__32963__$1);
re_frame.router.dispatch.call(null,event);
var G__32975 = cljs.core.next.call(null,seq__32963__$1);
var G__32976 = null;
var G__32977 = (0);
var G__32978 = (0);
seq__32963 = G__32975;
chunk__32964 = G__32976;
count__32965 = G__32977;
i__32966 = G__32978;
continue;
}
} else {
return null;
}
}
break;
}
}));
re_frame.fx.register.call(null,new cljs.core.Keyword(null,"deregister-event-handler","deregister-event-handler",-1096518994),(function (value){
var clear_event = cljs.core.partial.call(null,re_frame.registrar.clear_handlers,re_frame.events.kind);
if(cljs.core.sequential_QMARK_.call(null,value)){
var seq__32979 = cljs.core.seq.call(null,((cljs.core.sequential_QMARK_.call(null,value))?value:new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [value], null)));
var chunk__32980 = null;
var count__32981 = (0);
var i__32982 = (0);
while(true){
if((i__32982 < count__32981)){
var event = cljs.core._nth.call(null,chunk__32980,i__32982);
clear_event.call(null,event);
var G__32983 = seq__32979;
var G__32984 = chunk__32980;
var G__32985 = count__32981;
var G__32986 = (i__32982 + (1));
seq__32979 = G__32983;
chunk__32980 = G__32984;
count__32981 = G__32985;
i__32982 = G__32986;
continue;
} else {
var temp__4657__auto__ = cljs.core.seq.call(null,seq__32979);
if(temp__4657__auto__){
var seq__32979__$1 = temp__4657__auto__;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32979__$1)){
var c__25941__auto__ = cljs.core.chunk_first.call(null,seq__32979__$1);
var G__32987 = cljs.core.chunk_rest.call(null,seq__32979__$1);
var G__32988 = c__25941__auto__;
var G__32989 = cljs.core.count.call(null,c__25941__auto__);
var G__32990 = (0);
seq__32979 = G__32987;
chunk__32980 = G__32988;
count__32981 = G__32989;
i__32982 = G__32990;
continue;
} else {
var event = cljs.core.first.call(null,seq__32979__$1);
clear_event.call(null,event);
var G__32991 = cljs.core.next.call(null,seq__32979__$1);
var G__32992 = null;
var G__32993 = (0);
var G__32994 = (0);
seq__32979 = G__32991;
chunk__32980 = G__32992;
count__32981 = G__32993;
i__32982 = G__32994;
continue;
}
} else {
return null;
}
}
break;
}
} else {
return null;
}
}));
re_frame.fx.register.call(null,new cljs.core.Keyword(null,"db","db",993250759),(function (value){
return cljs.core.reset_BANG_.call(null,re_frame.db.app_db,value);
}));
//# sourceMappingURL=fx.js.map?rel=1603199198148

1
resources/public/js/compiled/out/re_frame/fx.js.map Normal file
View file

File diff suppressed because one or more lines are too long

198
resources/public/js/compiled/out/re_frame/interceptor.cljc Normal file
View file

@ -0,0 +1,198 @@
(ns re-frame.interceptor
(:require
[re-frame.loggers :refer [console]]
[re-frame.interop :refer [ratom? empty-queue debug-enabled?]]))
(def mandatory-interceptor-keys #{:id :after :before})
(defn interceptor?
[m]
(and (map? m)
(= mandatory-interceptor-keys (-> m keys set))))
(defn ->interceptor
"Create an interceptor from named arguments"
[& {:as m :keys [id before after]}]
(when debug-enabled?
(if-let [unknown-keys (seq (clojure.set/difference
(-> m keys set)
mandatory-interceptor-keys))]
(console :error "re-frame: ->interceptor " m " has unknown keys:" unknown-keys)))
{:id (or id :unnamed)
:before before
:after after })
;; -- Effect Helpers -----------------------------------------------------------------------------
(defn get-effect
([context]
(:effects context))
([context key]
(get-in context [:effects key]))
([context key not-found]
(get-in context [:effects key] not-found)))
(defn assoc-effect
[context key value]
(assoc-in context [:effects key] value))
;; -- CoEffect Helpers ---------------------------------------------------------------------------
(defn get-coeffect
([context]
(:coeffects context))
([context key]
(get-in context [:coeffects key]))
([context key not-found]
(get-in context [:coeffects key] not-found)))
(defn assoc-coeffect
[context key value]
(assoc-in context [:coeffects key] value))
(defn update-coeffect
[context key f & args]
(apply update-in context [:coeffects key] f args))
;; -- Execute Interceptor Chain ------------------------------------------------------------------
(defn- invoke-interceptor-fn
[context interceptor direction]
(if-let [f (get interceptor direction)]
(f context)
context))
(defn- invoke-interceptors
"Loop over all interceptors, calling `direction` function on each,
threading the value of `context` through every call.
`direction` is one of `:before` or `:after`.
Each iteration, the next interceptor to process is obtained from
context's `:queue`. After they are processed, interceptors are popped
from `:queue` and added to `:stack`.
After sufficient iteration, `:queue` will be empty, and `:stack` will
contain all interceptors processed.
Returns updated `context`. Ie. the `context` which has been threaded
through all interceptor functions.
Generally speaking, an interceptor's `:before` function will (if present)
add to a `context's` `:coeffects`, while it's `:after` function
will modify the `context`'s `:effects`. Very approximately.
But because all interceptor functions are given `context`, and can
return a modified version of it, the way is clear for an interceptor
to introspect the stack or queue, or even modify the queue
(add new interceptors via `enqueue`?). This is a very fluid arrangement."
([context direction]
(loop [context context]
(let [queue (:queue context)] ;; future interceptors
(if (empty? queue)
context
(let [interceptor (peek queue) ;; next interceptor to call
stack (:stack context)] ;; already completed interceptors
(recur (-> context
(assoc :queue (pop queue)
:stack (conj stack interceptor))
(invoke-interceptor-fn interceptor direction)))))))))
(defn enqueue
"Add a collection of `interceptors` to the end of `context's` execution `:queue`.
Returns the updated `context`.
In an advanced case, this function could allow an interceptor to add new
interceptors to the `:queue` of a context."
[context interceptors]
(update context :queue
(fnil into empty-queue)
interceptors))
(defn- context
"Create a fresh context"
([event interceptors]
(-> {}
(assoc-coeffect :event event)
(enqueue interceptors)))
([event interceptors db] ;; only used in tests, probably a hack, remove ? XXX
(-> (context event interceptors)
(assoc-coeffect :db db))))
(defn- change-direction
"Called on completion of `:before` processing, this function prepares/modifies
`context` for the backwards sweep of processing in which an interceptor
chain's `:after` fns are called.
At this point in processing, the `:queue` is empty and `:stack` holds all
the previously run interceptors. So this function enables the backwards walk
by priming `:queue` with what's currently in `:stack`"
[context]
(-> context
(dissoc :queue)
(enqueue (:stack context))))
(defn execute
"Executes the given chain (coll) of interceptors.
Each interceptor has this form:
{:before (fn [context] ...) ;; returns possibly modified context
:after (fn [context] ...)} ;; `identity` would be a noop
Walks the queue of iterceptors from beginning to end, calling the
`:before` fn on each, then reverse direction and walk backwards,
calling the `:after` fn on each.
The last interceptor in the chain presumably wraps an event
handler fn. So the overall goal of the process is to \"handle
the given event\".
Thread a `context` through all calls. `context` has this form:
{:coeffects {:event [:a-query-id :some-param]
:db <original contents of app-db>}
:effects {:db <new value for app-db>
:dispatch [:an-event-id :param1]}
:queue <a collection of further interceptors>
:stack <a collection of interceptors already walked>}
`context` has `:coeffects` and `:effects` which, if this was a web
server, would be somewhat anologous to `request` and `response`
respectively.
`coeffects` will contain data like `event` and the initial
state of `db` - the inputs required by the event handler
(sitting presumably on the end of the chain), while handler-returned
side effects are put into `:effects` including, but not limited to,
new values for `db`.
The first few interceptors in a chain will likely have `:before`
functions which \"prime\" the `context` by adding the event, and
the current state of app-db into `:coeffects`. But interceptors can
add whatever they want to `:coeffects` - perhaps the event handler needs
some information from localstore, or a random number, or access to
a DataScript connection.
Equally, some interceptors in the chain will have `:after` fn
which can process the side effects accumulated into `:effects`
including but, not limited to, updates to app-db.
Through both stages (before and after), `context` contains a `:queue`
of interceptors yet to be processed, and a `:stack` of interceptors
already done. In advanced cases, these values can be modified by the
functions through which the context is threaded."
[event-v interceptors]
(-> (context event-v interceptors)
(invoke-interceptors :before)
change-direction
(invoke-interceptors :after)))

1
resources/public/js/compiled/out/re_frame/interceptor.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

378
resources/public/js/compiled/out/re_frame/interceptor.js Normal file
View file

@ -0,0 +1,378 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.interceptor');
goog.require('cljs.core');
goog.require('re_frame.loggers');
goog.require('re_frame.interop');
re_frame.interceptor.mandatory_interceptor_keys = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"after","after",594996914),null,new cljs.core.Keyword(null,"id","id",-1388402092),null,new cljs.core.Keyword(null,"before","before",-1633692388),null], null), null);
re_frame.interceptor.interceptor_QMARK_ = (function re_frame$interceptor$interceptor_QMARK_(m){
return (cljs.core.map_QMARK_.call(null,m)) && (cljs.core._EQ_.call(null,re_frame.interceptor.mandatory_interceptor_keys,cljs.core.set.call(null,cljs.core.keys.call(null,m))));
});
/**
* Create an interceptor from named arguments
*/
re_frame.interceptor.__GT_interceptor = (function re_frame$interceptor$__GT_interceptor(var_args){
var args__26212__auto__ = [];
var len__26205__auto___32549 = arguments.length;
var i__26206__auto___32550 = (0);
while(true){
if((i__26206__auto___32550 < len__26205__auto___32549)){
args__26212__auto__.push((arguments[i__26206__auto___32550]));
var G__32551 = (i__26206__auto___32550 + (1));
i__26206__auto___32550 = G__32551;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((0) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((0)),(0),null)):null);
return re_frame.interceptor.__GT_interceptor.cljs$core$IFn$_invoke$arity$variadic(argseq__26213__auto__);
});
re_frame.interceptor.__GT_interceptor.cljs$core$IFn$_invoke$arity$variadic = (function (p__32546){
var map__32547 = p__32546;
var map__32547__$1 = ((((!((map__32547 == null)))?((((map__32547.cljs$lang$protocol_mask$partition0$ & (64))) || (map__32547.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__32547):map__32547);
var m = map__32547__$1;
var id = cljs.core.get.call(null,map__32547__$1,new cljs.core.Keyword(null,"id","id",-1388402092));
var before = cljs.core.get.call(null,map__32547__$1,new cljs.core.Keyword(null,"before","before",-1633692388));
var after = cljs.core.get.call(null,map__32547__$1,new cljs.core.Keyword(null,"after","after",594996914));
if(re_frame.interop.debug_enabled_QMARK_){
var temp__4655__auto___32552 = cljs.core.seq.call(null,clojure.set.difference.call(null,cljs.core.set.call(null,cljs.core.keys.call(null,m)),re_frame.interceptor.mandatory_interceptor_keys));
if(temp__4655__auto___32552){
var unknown_keys_32553 = temp__4655__auto___32552;
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: ->interceptor ",m," has unknown keys:",unknown_keys_32553);
} else {
}
} else {
}
return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"id","id",-1388402092),(function (){var or__25130__auto__ = id;
if(cljs.core.truth_(or__25130__auto__)){
return or__25130__auto__;
} else {
return new cljs.core.Keyword(null,"unnamed","unnamed",-26044928);
}
})(),new cljs.core.Keyword(null,"before","before",-1633692388),before,new cljs.core.Keyword(null,"after","after",594996914),after], null);
});
re_frame.interceptor.__GT_interceptor.cljs$lang$maxFixedArity = (0);
re_frame.interceptor.__GT_interceptor.cljs$lang$applyTo = (function (seq32545){
return re_frame.interceptor.__GT_interceptor.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq32545));
});
re_frame.interceptor.get_effect = (function re_frame$interceptor$get_effect(var_args){
var args32554 = [];
var len__26205__auto___32557 = arguments.length;
var i__26206__auto___32558 = (0);
while(true){
if((i__26206__auto___32558 < len__26205__auto___32557)){
args32554.push((arguments[i__26206__auto___32558]));
var G__32559 = (i__26206__auto___32558 + (1));
i__26206__auto___32558 = G__32559;
continue;
} else {
}
break;
}
var G__32556 = args32554.length;
switch (G__32556) {
case 1:
return re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32554.length)].join('')));
}
});
re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$1 = (function (context){
return new cljs.core.Keyword(null,"effects","effects",-282369292).cljs$core$IFn$_invoke$arity$1(context);
});
re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$2 = (function (context,key){
return cljs.core.get_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"effects","effects",-282369292),key], null));
});
re_frame.interceptor.get_effect.cljs$core$IFn$_invoke$arity$3 = (function (context,key,not_found){
return cljs.core.get_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"effects","effects",-282369292),key], null),not_found);
});
re_frame.interceptor.get_effect.cljs$lang$maxFixedArity = 3;
re_frame.interceptor.assoc_effect = (function re_frame$interceptor$assoc_effect(context,key,value){
return cljs.core.assoc_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"effects","effects",-282369292),key], null),value);
});
re_frame.interceptor.get_coeffect = (function re_frame$interceptor$get_coeffect(var_args){
var args32561 = [];
var len__26205__auto___32564 = arguments.length;
var i__26206__auto___32565 = (0);
while(true){
if((i__26206__auto___32565 < len__26205__auto___32564)){
args32561.push((arguments[i__26206__auto___32565]));
var G__32566 = (i__26206__auto___32565 + (1));
i__26206__auto___32565 = G__32566;
continue;
} else {
}
break;
}
var G__32563 = args32561.length;
switch (G__32563) {
case 1:
return re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32561.length)].join('')));
}
});
re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$1 = (function (context){
return new cljs.core.Keyword(null,"coeffects","coeffects",497912985).cljs$core$IFn$_invoke$arity$1(context);
});
re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$2 = (function (context,key){
return cljs.core.get_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),key], null));
});
re_frame.interceptor.get_coeffect.cljs$core$IFn$_invoke$arity$3 = (function (context,key,not_found){
return cljs.core.get_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),key], null),not_found);
});
re_frame.interceptor.get_coeffect.cljs$lang$maxFixedArity = 3;
re_frame.interceptor.assoc_coeffect = (function re_frame$interceptor$assoc_coeffect(context,key,value){
return cljs.core.assoc_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),key], null),value);
});
re_frame.interceptor.update_coeffect = (function re_frame$interceptor$update_coeffect(var_args){
var args__26212__auto__ = [];
var len__26205__auto___32572 = arguments.length;
var i__26206__auto___32573 = (0);
while(true){
if((i__26206__auto___32573 < len__26205__auto___32572)){
args__26212__auto__.push((arguments[i__26206__auto___32573]));
var G__32574 = (i__26206__auto___32573 + (1));
i__26206__auto___32573 = G__32574;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((3) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((3)),(0),null)):null);
return re_frame.interceptor.update_coeffect.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__26213__auto__);
});
re_frame.interceptor.update_coeffect.cljs$core$IFn$_invoke$arity$variadic = (function (context,key,f,args){
return cljs.core.apply.call(null,cljs.core.update_in,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),key], null),f,args);
});
re_frame.interceptor.update_coeffect.cljs$lang$maxFixedArity = (3);
re_frame.interceptor.update_coeffect.cljs$lang$applyTo = (function (seq32568){
var G__32569 = cljs.core.first.call(null,seq32568);
var seq32568__$1 = cljs.core.next.call(null,seq32568);
var G__32570 = cljs.core.first.call(null,seq32568__$1);
var seq32568__$2 = cljs.core.next.call(null,seq32568__$1);
var G__32571 = cljs.core.first.call(null,seq32568__$2);
var seq32568__$3 = cljs.core.next.call(null,seq32568__$2);
return re_frame.interceptor.update_coeffect.cljs$core$IFn$_invoke$arity$variadic(G__32569,G__32570,G__32571,seq32568__$3);
});
re_frame.interceptor.invoke_interceptor_fn = (function re_frame$interceptor$invoke_interceptor_fn(context,interceptor,direction){
var temp__4655__auto__ = cljs.core.get.call(null,interceptor,direction);
if(cljs.core.truth_(temp__4655__auto__)){
var f = temp__4655__auto__;
return f.call(null,context);
} else {
return context;
}
});
/**
* Loop over all interceptors, calling `direction` function on each,
* threading the value of `context` through every call.
*
* `direction` is one of `:before` or `:after`.
*
* Each iteration, the next interceptor to process is obtained from
* context's `:queue`. After they are processed, interceptors are popped
* from `:queue` and added to `:stack`.
*
* After sufficient iteration, `:queue` will be empty, and `:stack` will
* contain all interceptors processed.
*
* Returns updated `context`. Ie. the `context` which has been threaded
* through all interceptor functions.
*
* Generally speaking, an interceptor's `:before` function will (if present)
* add to a `context's` `:coeffects`, while it's `:after` function
* will modify the `context`'s `:effects`. Very approximately.
*
* But because all interceptor functions are given `context`, and can
* return a modified version of it, the way is clear for an interceptor
* to introspect the stack or queue, or even modify the queue
* (add new interceptors via `enqueue`?). This is a very fluid arrangement.
*/
re_frame.interceptor.invoke_interceptors = (function re_frame$interceptor$invoke_interceptors(context,direction){
var context__$1 = context;
while(true){
var queue = new cljs.core.Keyword(null,"queue","queue",1455835879).cljs$core$IFn$_invoke$arity$1(context__$1);
if(cljs.core.empty_QMARK_.call(null,queue)){
return context__$1;
} else {
var interceptor = cljs.core.peek.call(null,queue);
var stack = new cljs.core.Keyword(null,"stack","stack",-793405930).cljs$core$IFn$_invoke$arity$1(context__$1);
var G__32575 = re_frame.interceptor.invoke_interceptor_fn.call(null,cljs.core.assoc.call(null,context__$1,new cljs.core.Keyword(null,"queue","queue",1455835879),cljs.core.pop.call(null,queue),new cljs.core.Keyword(null,"stack","stack",-793405930),cljs.core.conj.call(null,stack,interceptor)),interceptor,direction);
context__$1 = G__32575;
continue;
}
break;
}
});
/**
* Add a collection of `interceptors` to the end of `context's` execution `:queue`.
* Returns the updated `context`.
*
* In an advanced case, this function could allow an interceptor to add new
* interceptors to the `:queue` of a context.
*/
re_frame.interceptor.enqueue = (function re_frame$interceptor$enqueue(context,interceptors){
return cljs.core.update.call(null,context,new cljs.core.Keyword(null,"queue","queue",1455835879),cljs.core.fnil.call(null,cljs.core.into,re_frame.interop.empty_queue),interceptors);
});
/**
* Create a fresh context
*/
re_frame.interceptor.context = (function re_frame$interceptor$context(var_args){
var args32576 = [];
var len__26205__auto___32579 = arguments.length;
var i__26206__auto___32580 = (0);
while(true){
if((i__26206__auto___32580 < len__26205__auto___32579)){
args32576.push((arguments[i__26206__auto___32580]));
var G__32581 = (i__26206__auto___32580 + (1));
i__26206__auto___32580 = G__32581;
continue;
} else {
}
break;
}
var G__32578 = args32576.length;
switch (G__32578) {
case 2:
return re_frame.interceptor.context.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.interceptor.context.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32576.length)].join('')));
}
});
re_frame.interceptor.context.cljs$core$IFn$_invoke$arity$2 = (function (event,interceptors){
return re_frame.interceptor.enqueue.call(null,re_frame.interceptor.assoc_coeffect.call(null,cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,"event","event",301435442),event),interceptors);
});
re_frame.interceptor.context.cljs$core$IFn$_invoke$arity$3 = (function (event,interceptors,db){
return re_frame.interceptor.assoc_coeffect.call(null,re_frame.interceptor.context.call(null,event,interceptors),new cljs.core.Keyword(null,"db","db",993250759),db);
});
re_frame.interceptor.context.cljs$lang$maxFixedArity = 3;
/**
* Called on completion of `:before` processing, this function prepares/modifies
* `context` for the backwards sweep of processing in which an interceptor
* chain's `:after` fns are called.
*
* At this point in processing, the `:queue` is empty and `:stack` holds all
* the previously run interceptors. So this function enables the backwards walk
* by priming `:queue` with what's currently in `:stack`
*/
re_frame.interceptor.change_direction = (function re_frame$interceptor$change_direction(context){
return re_frame.interceptor.enqueue.call(null,cljs.core.dissoc.call(null,context,new cljs.core.Keyword(null,"queue","queue",1455835879)),new cljs.core.Keyword(null,"stack","stack",-793405930).cljs$core$IFn$_invoke$arity$1(context));
});
/**
* Executes the given chain (coll) of interceptors.
*
* Each interceptor has this form:
* {:before (fn [context] ...) ;; returns possibly modified context
* :after (fn [context] ...)} ;; `identity` would be a noop
*
* Walks the queue of iterceptors from beginning to end, calling the
* `:before` fn on each, then reverse direction and walk backwards,
* calling the `:after` fn on each.
*
* The last interceptor in the chain presumably wraps an event
* handler fn. So the overall goal of the process is to "handle
* the given event".
*
* Thread a `context` through all calls. `context` has this form:
*
* {:coeffects {:event [:a-query-id :some-param]
* :db <original contents of app-db>}
* :effects {:db <new value for app-db>
* :dispatch [:an-event-id :param1]}
* :queue <a collection of further interceptors>
* :stack <a collection of interceptors already walked>}
*
* `context` has `:coeffects` and `:effects` which, if this was a web
* server, would be somewhat anologous to `request` and `response`
* respectively.
*
* `coeffects` will contain data like `event` and the initial
* state of `db` - the inputs required by the event handler
* (sitting presumably on the end of the chain), while handler-returned
* side effects are put into `:effects` including, but not limited to,
* new values for `db`.
*
* The first few interceptors in a chain will likely have `:before`
* functions which "prime" the `context` by adding the event, and
* the current state of app-db into `:coeffects`. But interceptors can
* add whatever they want to `:coeffects` - perhaps the event handler needs
* some information from localstore, or a random number, or access to
* a DataScript connection.
*
* Equally, some interceptors in the chain will have `:after` fn
* which can process the side effects accumulated into `:effects`
* including but, not limited to, updates to app-db.
*
* Through both stages (before and after), `context` contains a `:queue`
* of interceptors yet to be processed, and a `:stack` of interceptors
* already done. In advanced cases, these values can be modified by the
* functions through which the context is threaded.
*/
re_frame.interceptor.execute = (function re_frame$interceptor$execute(event_v,interceptors){
return re_frame.interceptor.invoke_interceptors.call(null,re_frame.interceptor.change_direction.call(null,re_frame.interceptor.invoke_interceptors.call(null,re_frame.interceptor.context.call(null,event_v,interceptors),new cljs.core.Keyword(null,"before","before",-1633692388))),new cljs.core.Keyword(null,"after","after",594996914));
});
//# sourceMappingURL=interceptor.js.map?rel=1603199197339

1
resources/public/js/compiled/out/re_frame/interceptor.js.map Normal file
View file

File diff suppressed because one or more lines are too long

56
resources/public/js/compiled/out/re_frame/interop.cljs Normal file
View file

@ -0,0 +1,56 @@
(ns re-frame.interop
(:require [goog.async.nextTick]
[reagent.core]
[reagent.ratom]))
(def next-tick goog.async.nextTick)
(def empty-queue #queue [])
(def after-render reagent.core/after-render)
;; Make sure the Google Closure compiler sees this as a boolean constant,
;; otherwise Dead Code Elimination won't happen in `:advanced` builds.
;; Type hints have been liberally sprinkled.
;; https://developers.google.com/closure/compiler/docs/js-for-compiler
(def ^boolean debug-enabled? "@define {boolean}" ^boolean js/goog.DEBUG)
(defn ratom [x]
(reagent.core/atom x))
(defn ratom? [x]
(satisfies? reagent.ratom/IReactiveAtom x))
(defn deref? [x]
(satisfies? IDeref x))
(defn make-reaction [f]
(reagent.ratom/make-reaction f))
(defn add-on-dispose! [a-ratom f]
(reagent.ratom/add-on-dispose! a-ratom f))
(defn dispose! [a-ratom]
(reagent.ratom/dispose! a-ratom))
(defn set-timeout! [f ms]
(js/setTimeout f ms))
(defn now []
(if (exists? js/performance.now)
(js/performance.now)
(js/Date.now)))
(defn reagent-id
"Produces an id for reactive Reagent values
e.g. reactions, ratoms, cursors."
[reactive-val]
(when (implements? reagent.ratom/IReactiveAtom reactive-val)
(str (condp instance? reactive-val
reagent.ratom/RAtom "ra"
reagent.ratom/RCursor "rc"
reagent.ratom/Reaction "rx"
reagent.ratom/Track "tr"
"other")
(hash reactive-val))))

1
resources/public/js/compiled/out/re_frame/interop.cljs.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

97
resources/public/js/compiled/out/re_frame/interop.js Normal file
View file

@ -0,0 +1,97 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.interop');
goog.require('cljs.core');
goog.require('goog.async.nextTick');
goog.require('reagent.core');
goog.require('reagent.ratom');
re_frame.interop.next_tick = goog.async.nextTick;
re_frame.interop.empty_queue = cljs.core.into.call(null,cljs.core.PersistentQueue.EMPTY,cljs.core.PersistentVector.EMPTY);
re_frame.interop.after_render = reagent.core.after_render;
/**
* @define {boolean}
*/
re_frame.interop.debug_enabled_QMARK_ = goog.DEBUG;
re_frame.interop.ratom = (function re_frame$interop$ratom(x){
return reagent.core.atom.call(null,x);
});
re_frame.interop.ratom_QMARK_ = (function re_frame$interop$ratom_QMARK_(x){
if(!((x == null))){
if((false) || (x.reagent$ratom$IReactiveAtom$)){
return true;
} else {
if((!x.cljs$lang$protocol_mask$partition$)){
return cljs.core.native_satisfies_QMARK_.call(null,reagent.ratom.IReactiveAtom,x);
} else {
return false;
}
}
} else {
return cljs.core.native_satisfies_QMARK_.call(null,reagent.ratom.IReactiveAtom,x);
}
});
re_frame.interop.deref_QMARK_ = (function re_frame$interop$deref_QMARK_(x){
if(!((x == null))){
if(((x.cljs$lang$protocol_mask$partition0$ & (32768))) || (x.cljs$core$IDeref$)){
return true;
} else {
if((!x.cljs$lang$protocol_mask$partition0$)){
return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IDeref,x);
} else {
return false;
}
}
} else {
return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IDeref,x);
}
});
re_frame.interop.make_reaction = (function re_frame$interop$make_reaction(f){
return reagent.ratom.make_reaction.call(null,f);
});
re_frame.interop.add_on_dispose_BANG_ = (function re_frame$interop$add_on_dispose_BANG_(a_ratom,f){
return reagent.ratom.add_on_dispose_BANG_.call(null,a_ratom,f);
});
re_frame.interop.dispose_BANG_ = (function re_frame$interop$dispose_BANG_(a_ratom){
return reagent.ratom.dispose_BANG_.call(null,a_ratom);
});
re_frame.interop.set_timeout_BANG_ = (function re_frame$interop$set_timeout_BANG_(f,ms){
return setTimeout(f,ms);
});
re_frame.interop.now = (function re_frame$interop$now(){
if(typeof performance.now !== 'undefined'){
return performance.now();
} else {
return Date.now();
}
});
/**
* Produces an id for reactive Reagent values
* e.g. reactions, ratoms, cursors.
*/
re_frame.interop.reagent_id = (function re_frame$interop$reagent_id(reactive_val){
if(((!((reactive_val == null)))?(((false) || (reactive_val.reagent$ratom$IReactiveAtom$))?true:false):false)){
return [cljs.core.str((function (){var pred__27104 = cljs.core.instance_QMARK_;
var expr__27105 = reactive_val;
if(cljs.core.truth_(pred__27104.call(null,reagent.ratom.RAtom,expr__27105))){
return "ra";
} else {
if(cljs.core.truth_(pred__27104.call(null,reagent.ratom.RCursor,expr__27105))){
return "rc";
} else {
if(cljs.core.truth_(pred__27104.call(null,reagent.ratom.Reaction,expr__27105))){
return "rx";
} else {
if(cljs.core.truth_(pred__27104.call(null,reagent.ratom.Track,expr__27105))){
return "tr";
} else {
return "other";
}
}
}
}
})()),cljs.core.str(cljs.core.hash.call(null,reactive_val))].join('');
} else {
return null;
}
});
//# sourceMappingURL=interop.js.map?rel=1603199189446

1
resources/public/js/compiled/out/re_frame/interop.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/interop.js","sources":["interop.cljs?rel=1603199189447"],"lineCount":97,"mappings":";AAAA;;;;;AAKA,AAAKA,6BAAUC;AAEf,+BAAA,AAAAC,yBAAAC,gCAAA,xFAAKC;AAEL,AAAKC,gCAAaC;AAMlB;;;AAAcC,wCAA4CC;AAE1D,yBAAA,zBAAMC,0DAAOC;AAAb,AACE,OAACC,4BAAkBD;;AAErB,gCAAA,hCAAME,wEAAQF;AAAd,AACE,GAAA,EAAA,MAAA,LAAwCA;AAAxC,GAAA,CAAA,WAAA,AAAwCA;AAAxC;;AAAA,GAAA,EAAA,AAAwCA;AAAxC,OAAAG,4CAAYC,4BAA4BJ;;AAAxC;;;;AAAA,OAAAG,4CAAYC,4BAA4BJ;;;AAE1C,gCAAA,hCAAMK,wEAAQL;AAAd,AACE,GAAA,EAAA,MAAA,LAAmBA;AAAnB,GAAA,CAAA,CAAA,wCAAA,cAAA,tDAAmBA,sDAAAA;AAAnB;;AAAA,GAAA,EAAA,AAAmBA;AAAnB,OAAAG,4CAAYG,iBAAON;;AAAnB;;;;AAAA,OAAAG,4CAAYG,iBAAON;;;AAGrB,iCAAA,jCAAMO,0EAAeC;AAArB,AACE,OAACC,sCAA4BD;;AAE\/B,wCAAA,xCAAME,wFAAiBC,QAAQH;AAA\/B,AACE,OAACI,6CAA8BD,QAAQH;;AAEzC,iCAAA,jCAAMK,0EAAUF;AAAhB,AACC,OAACG,sCAAuBH;;AAEzB,qCAAA,rCAAMI,kFAAcP,EAAEQ;AAAtB,AACE,OAACC,WAAcT,EAAEQ;;AAEnB,uBAAA,vBAAME;AAAN,AACE,GAAI,OAASC;AACX,OAACA;;AACD,OAACC;;;AAEL;;;;8BAAA,9BAAMC,oEAGHC;AAHH,AAIE,GAAM,EAAA,EAAA,iBAAA,QAAA,EAAA,CAAA,WAAA,4CAAA,KAAA,OAAA,9FAAyCA,sCAAAA;AAA\/C,AACE,sBAAK,iBAAAC,cAAOE;IAAPD,cAAiBF;AAAjB,AAAA,oBAAA,AAAAC,0CAAAC,pBACEE;AADF;;AAAA,oBAAA,AAAAH,4CAAAC,tBAEEG;AAFF;;AAAA,oBAAA,AAAAJ,6CAAAC,vBAGEI;AAHF;;AAAA,oBAAA,AAAAL,0CAAAC,pBAIEK;AAJF;;AAAA;;;;;oBAMA,AAACC,yBAAKR;;AAPb","names":["re-frame.interop\/next-tick","goog\/async.nextTick","cljs.core\/into","cljs\/core.PersistentQueue.EMPTY","re-frame.interop\/empty-queue","re-frame.interop\/after-render","reagent.core\/after-render","re-frame.interop\/debug-enabled?","js\/goog.DEBUG","re-frame.interop\/ratom","x","reagent.core\/atom","re-frame.interop\/ratom?","cljs.core\/native-satisfies?","reagent.ratom\/IReactiveAtom","re-frame.interop\/deref?","cljs.core\/IDeref","re-frame.interop\/make-reaction","f","reagent.ratom\/make-reaction","re-frame.interop\/add-on-dispose!","a-ratom","reagent.ratom\/add-on-dispose!","re-frame.interop\/dispose!","reagent.ratom\/dispose!","re-frame.interop\/set-timeout!","ms","js\/setTimeout","re-frame.interop\/now","js\/performance.now","js\/Date.now","re-frame.interop\/reagent-id","reactive-val","pred__27104","expr__27105","cljs.core\/instance?","reagent.ratom\/RAtom","reagent.ratom\/RCursor","reagent.ratom\/Reaction","reagent.ratom\/Track","cljs.core\/hash"]}

51
resources/public/js/compiled/out/re_frame/loggers.cljc Normal file
View file

@ -0,0 +1,51 @@
(ns re-frame.loggers
(:require
[clojure.set :refer [difference]]
#?@(:clj [[clojure.string :as str]
[clojure.tools.logging :as log]])))
#?(:clj (defn log [level & args]
(log/log level (if (= 1 (count args))
(first args)
(str/join " " args)))))
;; XXX should loggers be put in the registrar ??
(def ^:private loggers
"Holds the current set of logging functions.
By default, re-frame uses the functions provided by js/console.
Use `set-loggers!` to change these defaults
"
(atom #?(:cljs {:log (js/console.log.bind js/console)
:warn (js/console.warn.bind js/console)
:error (js/console.error.bind js/console)
:group (if (.-group js/console) ;; console.group does not exist < IE 11
(js/console.group.bind js/console)
(js/console.log.bind js/console))
:groupEnd (if (.-groupEnd js/console) ;; console.groupEnd does not exist < IE 11
(js/console.groupEnd.bind js/console)
#())})
;; clojure versions
#?(:clj {:log (partial log :info)
:warn (partial log :warn)
:error (partial log :error)
:group (partial log :info)
:groupEnd #()})))
(defn console
[level & args]
(assert (contains? @loggers level) (str "re-frame: log called with unknown level: " level))
(apply (level @loggers) args))
(defn set-loggers!
"Change the set (or a subset) of logging functions used by re-frame.
`new-loggers` should be a map with the same keys as `loggers` (above)"
[new-loggers]
(assert (empty? (difference (set (keys new-loggers)) (-> @loggers keys set))) "Unknown keys in new-loggers")
(swap! loggers merge new-loggers))
(defn get-loggers
"Get the current logging functions used by re-frame."
[]
@loggers)

1
resources/public/js/compiled/out/re_frame/loggers.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {difference clojure.set}, :excludes #{}, :name re-frame.loggers, :imports nil, :requires {clojure.set clojure.set}, :uses {difference clojure.set}, :defs {loggers {:name re-frame.loggers/loggers, :file "docs/js/compiled/out/re_frame/loggers.cljc", :line 14, :column 1, :end-line 14, :end-column 23, :private true, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/loggers.cljc", :line 14, :column 16, :end-line 14, :end-column 23, :private true}, :doc "Holds the current set of logging functions.\n By default, re-frame uses the functions provided by js/console.\n Use `set-loggers!` to change these defaults\n "}, console {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/loggers.cljc", :line 35, :column 7, :end-line 35, :end-column 14, :arglists (quote ([level & args])), :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(level args)], :arglists ([level & args]), :arglists-meta (nil)}}, :name re-frame.loggers/console, :variadic true, :file "docs/js/compiled/out/re_frame/loggers.cljc", :end-column 14, :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(level args)], :arglists ([level & args]), :arglists-meta (nil)}, :method-params [(level args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 35, :end-line 35, :max-fixed-arity 1, :fn-var true, :arglists ([level & args])}, set-loggers! {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/loggers.cljc", :line 41, :column 7, :end-line 41, :end-column 19, :arglists (quote ([new-loggers])), :doc "Change the set (or a subset) of logging functions used by re-frame.\n `new-loggers` should be a map with the same keys as `loggers` (above)"}, :name re-frame.loggers/set-loggers!, :variadic false, :file "docs/js/compiled/out/re_frame/loggers.cljc", :end-column 19, :method-params ([new-loggers]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 41, :end-line 41, :max-fixed-arity 1, :fn-var true, :arglists (quote ([new-loggers])), :doc "Change the set (or a subset) of logging functions used by re-frame.\n `new-loggers` should be a map with the same keys as `loggers` (above)"}, get-loggers {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/loggers.cljc", :line 48, :column 7, :end-line 48, :end-column 18, :arglists (quote ([])), :doc "Get the current logging functions used by re-frame."}, :name re-frame.loggers/get-loggers, :variadic false, :file "docs/js/compiled/out/re_frame/loggers.cljc", :end-column 18, :method-params ([]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 48, :end-line 48, :max-fixed-arity 0, :fn-var true, :arglists (quote ([])), :doc "Get the current logging functions used by re-frame."}}, :require-macros nil, :cljs.analyzer/constants {:seen #{:group :warn :error :groupEnd :log}, :order [:log :warn :error :group :groupEnd]}, :doc nil}

70
resources/public/js/compiled/out/re_frame/loggers.js Normal file
View file

@ -0,0 +1,70 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.loggers');
goog.require('cljs.core');
goog.require('clojure.set');
/**
* Holds the current set of logging functions.
* By default, re-frame uses the functions provided by js/console.
* Use `set-loggers!` to change these defaults
*
*/
re_frame.loggers.loggers = cljs.core.atom.call(null,new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,"log","log",-1595516004),console.log.bind(console),new cljs.core.Keyword(null,"warn","warn",-436710552),console.warn.bind(console),new cljs.core.Keyword(null,"error","error",-978969032),console.error.bind(console),new cljs.core.Keyword(null,"group","group",582596132),(cljs.core.truth_(console.group)?console.group.bind(console):console.log.bind(console)),new cljs.core.Keyword(null,"groupEnd","groupEnd",-337721382),(cljs.core.truth_(console.groupEnd)?console.groupEnd.bind(console):(function (){
return cljs.core.List.EMPTY;
}))], null));
re_frame.loggers.console = (function re_frame$loggers$console(var_args){
var args__26212__auto__ = [];
var len__26205__auto___32540 = arguments.length;
var i__26206__auto___32541 = (0);
while(true){
if((i__26206__auto___32541 < len__26205__auto___32540)){
args__26212__auto__.push((arguments[i__26206__auto___32541]));
var G__32542 = (i__26206__auto___32541 + (1));
i__26206__auto___32541 = G__32542;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((1) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((1)),(0),null)):null);
return re_frame.loggers.console.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__26213__auto__);
});
re_frame.loggers.console.cljs$core$IFn$_invoke$arity$variadic = (function (level,args){
if(cljs.core.contains_QMARK_.call(null,cljs.core.deref.call(null,re_frame.loggers.loggers),level)){
} else {
throw (new Error([cljs.core.str("Assert failed: "),cljs.core.str([cljs.core.str("re-frame: log called with unknown level: "),cljs.core.str(level)].join('')),cljs.core.str("\n"),cljs.core.str("(contains? (clojure.core/deref loggers) level)")].join('')));
}
return cljs.core.apply.call(null,level.call(null,cljs.core.deref.call(null,re_frame.loggers.loggers)),args);
});
re_frame.loggers.console.cljs$lang$maxFixedArity = (1);
re_frame.loggers.console.cljs$lang$applyTo = (function (seq32538){
var G__32539 = cljs.core.first.call(null,seq32538);
var seq32538__$1 = cljs.core.next.call(null,seq32538);
return re_frame.loggers.console.cljs$core$IFn$_invoke$arity$variadic(G__32539,seq32538__$1);
});
/**
* Change the set (or a subset) of logging functions used by re-frame.
* `new-loggers` should be a map with the same keys as `loggers` (above)
*/
re_frame.loggers.set_loggers_BANG_ = (function re_frame$loggers$set_loggers_BANG_(new_loggers){
if(cljs.core.empty_QMARK_.call(null,clojure.set.difference.call(null,cljs.core.set.call(null,cljs.core.keys.call(null,new_loggers)),cljs.core.set.call(null,cljs.core.keys.call(null,cljs.core.deref.call(null,re_frame.loggers.loggers)))))){
} else {
throw (new Error([cljs.core.str("Assert failed: "),cljs.core.str("Unknown keys in new-loggers"),cljs.core.str("\n"),cljs.core.str("(empty? (difference (set (keys new-loggers)) (-> (clojure.core/deref loggers) keys set)))")].join('')));
}
return cljs.core.swap_BANG_.call(null,re_frame.loggers.loggers,cljs.core.merge,new_loggers);
});
/**
* Get the current logging functions used by re-frame.
*/
re_frame.loggers.get_loggers = (function re_frame$loggers$get_loggers(){
return cljs.core.deref.call(null,re_frame.loggers.loggers);
});
//# sourceMappingURL=loggers.js.map?rel=1603199197167

1
resources/public/js/compiled/out/re_frame/loggers.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/loggers.js","sources":["loggers.cljc?rel=1603199197168"],"lineCount":70,"mappings":";AAAA;;;AAaA;;;;;;AAAeA,2BAKb,yBAAA,2CAAA,8EAAA,gFAAA,mFAAA,8IAAA,ncAACC,wHAA0B,AAACC,iBAAsBC,8DACvB,AAACC,kBAAsBD,gEACvB,AAACE,mBAAsBF,+DACvB,kBAAI,AAASA,eACX,AAACG,mBAAsBH,SACvB,AAACD,iBAAsBC,uEACzB,mEAAA,jDAAI,AAAYA,kBACd,AAACI,sBAAyBJ;AAD5B,AAAA;;AAU7B,AAAA,2BAAA,mCAAAK,9DAAMM;AAAN,AAAA,IAAAL,sBAAA;AAAA,AAAA,IAAAC,2BAAA,AAAA;AAAA,AAAA,IAAAC,yBAAA;;AAAA,AAAA,GAAA,CAAAA,yBAAAD;AAAA,AAAA,AAAAD,yBAAA,CAAA,UAAAE;;AAAA,eAAA,CAAAA,yBAAA;;;;AAAA;;;;AAAA,IAAAC,wBAAA,EAAA,CAAA,MAAA,AAAAH,6BAAA,AAAA,KAAAI,qBAAA,AAAAJ,0BAAA,KAAA,IAAA,OAAA;AAAA,AAAA,OAAAK,8DAAA,CAAA,UAAA,MAAAF;;;AAAA,AAAA,AAAA,AAAAE,gEAAA,WACGK,MAAQC;AADX,AAEE,GAAQ,oCAAA,AAAAE,pCAACC,8DAAWvB,0BAAQmB;AAA5B;AAAA,AAAA,MAAA,KAAAE,MAAA,eAAA,2IAAA,oBAAA,9HAAmC,eAAA,2DAAiDF;;;AACpF,OAACK,0BAAM,gBAAA,AAAAF,hBAACH,0CAAOnB,2BAASoB;;;AAH1B,AAAA,AAAAN,mDAAA;;AAAA,AAAA,AAAAA,6CAAA,WAAAC;AAAA,AAAA,IAAAC,WAAA,AAAAC,0BAAAF;IAAAA,eAAA,AAAAG,yBAAAH;AAAA,AAAA,OAAAD,8DAAAE,SAAAD;;;AAAA,AAMA;;;;qCAAA,rCAAMU,kFAGHC;AAHH,AAIE,GAAS,AAACC,iCAAO,AAACC,iCAAW,AAACC,wBAAI,AAACC,yBAAKJ,cAAc,wBAAA,yBAAA,AAAAJ,0BAAKtB,nDAAQ8B,xBAAKD;AAAxE;AAAA,AAAA,MAAA,KAAAR,MAAA,eAAA,iCAAA,6CAAA,oBAAA;;;AACA,OAACU,+BAAM\/B,yBAAQgC,gBAAMN;;AAEvB;;;+BAAA,\/BAAMO;AAAN,AAAA,OAAAX,0BAGGtB","names":["re-frame.loggers\/loggers","cljs.core\/atom","js\/console.log.bind","js\/console","js\/console.warn.bind","js\/console.error.bind","js\/console.group.bind","js\/console.groupEnd.bind","var_args","args__26212__auto__","len__26205__auto__","i__26206__auto__","argseq__26213__auto__","cljs.core\/IndexedSeq","re-frame.loggers\/console","seq32538","G__32539","cljs.core\/first","cljs.core\/next","level","args","js\/Error","cljs.core\/deref","cljs.core\/contains?","cljs.core\/apply","re-frame.loggers\/set-loggers!","new-loggers","cljs.core\/empty?","clojure.set\/difference","cljs.core\/set","cljs.core\/keys","cljs.core\/swap!","cljs.core\/merge","re-frame.loggers\/get-loggers"]}

56
resources/public/js/compiled/out/re_frame/registrar.cljc Normal file
View file

@ -0,0 +1,56 @@
(ns re-frame.registrar
"In many places, re-frame asks you to associate an `id` (keyword)
with a `handler` (function). This namespace contains the
central registry of such associations."
(:require [re-frame.interop :refer [debug-enabled?]]
[re-frame.loggers :refer [console]]))
;; kinds of handlers
(def kinds #{:event :fx :cofx :sub})
;; This atom contains a register of all handlers.
;; Contains a map keyed first by `kind` (of handler), and then `id`.
;; Leaf nodes are handlers.
(def kind->id->handler (atom {}))
(defn get-handler
([kind]
(get @kind->id->handler kind))
([kind id]
(-> (get @kind->id->handler kind)
(get id)))
([kind id required?]
(let [handler (get-handler kind id)]
(when debug-enabled? ;; This is in a separate when so Closure DCE can run
(when (and required? (nil? handler)) ;; Otherwise you'd need to type hint the and with a ^boolean for DCE.
(console :error "re-frame: no " (str kind) " handler registered for:" id)))
handler)))
(defn register-handler
[kind id handler-fn]
(when debug-enabled? ;; This is in a separate when so Closure DCE can run
(when (get-handler kind id false)
(console :warn "re-frame: overwriting" (str kind) "handler for:" id))) ;; allow it, but warn. Happens on figwheel reloads.
(swap! kind->id->handler assoc-in [kind id] handler-fn)
handler-fn) ;; note: returns the just registered handler
(defn clear-handlers
([] ;; clear all kinds
(reset! kind->id->handler {}))
([kind] ;; clear all handlers for this kind
(assert (kinds kind))
(swap! kind->id->handler dissoc kind))
([kind id] ;; clear a single handler for a kind
(assert (kinds kind))
(if (get-handler kind id)
(swap! kind->id->handler update-in [kind] dissoc id)
(console :warn "re-frame: can't clear" (str kind) "handler for" (str id ". Handler not found.")))))

1
resources/public/js/compiled/out/re_frame/registrar.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {console re-frame.loggers, debug-enabled? re-frame.interop}, :excludes #{}, :name re-frame.registrar, :imports nil, :requires {re-frame.interop re-frame.interop, re-frame.loggers re-frame.loggers}, :uses {console re-frame.loggers, debug-enabled? re-frame.interop}, :defs {kinds {:name re-frame.registrar/kinds, :file "docs/js/compiled/out/re_frame/registrar.cljc", :line 10, :column 1, :end-line 10, :end-column 11, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/registrar.cljc", :line 10, :column 6, :end-line 10, :end-column 11}}, kind->id->handler {:name re-frame.registrar/kind->id->handler, :file "docs/js/compiled/out/re_frame/registrar.cljc", :line 15, :column 1, :end-line 15, :end-column 23, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/registrar.cljc", :line 15, :column 6, :end-line 15, :end-column 23}}, get-handler {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/registrar.cljc", :line 18, :column 7, :end-line 18, :end-column 18, :arglists (quote ([kind] [kind id] [kind id required?])), :top-fn {:variadic false, :max-fixed-arity 3, :method-params ([kind] [kind id] [kind id required?]), :arglists ([kind] [kind id] [kind id required?]), :arglists-meta (nil nil nil)}}, :name re-frame.registrar/get-handler, :variadic false, :file "docs/js/compiled/out/re_frame/registrar.cljc", :end-column 18, :top-fn {:variadic false, :max-fixed-arity 3, :method-params ([kind] [kind id] [kind id required?]), :arglists ([kind] [kind id] [kind id required?]), :arglists-meta (nil nil nil)}, :method-params ([kind] [kind id] [kind id required?]), :protocol-impl nil, :arglists-meta (nil nil nil), :column 1, :line 18, :end-line 18, :max-fixed-arity 3, :fn-var true, :arglists ([kind] [kind id] [kind id required?])}, register-handler {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/registrar.cljc", :line 35, :column 7, :end-line 35, :end-column 23, :arglists (quote ([kind id handler-fn]))}, :name re-frame.registrar/register-handler, :variadic false, :file "docs/js/compiled/out/re_frame/registrar.cljc", :end-column 23, :method-params ([kind id handler-fn]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 35, :end-line 35, :max-fixed-arity 3, :fn-var true, :arglists (quote ([kind id handler-fn]))}, clear-handlers {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/registrar.cljc", :line 44, :column 7, :end-line 44, :end-column 21, :arglists (quote ([] [kind] [kind id])), :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([] [kind] [kind id]), :arglists ([] [kind] [kind id]), :arglists-meta (nil nil nil)}}, :name re-frame.registrar/clear-handlers, :variadic false, :file "docs/js/compiled/out/re_frame/registrar.cljc", :end-column 21, :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([] [kind] [kind id]), :arglists ([] [kind] [kind id]), :arglists-meta (nil nil nil)}, :method-params ([] [kind] [kind id]), :protocol-impl nil, :arglists-meta (nil nil nil), :column 1, :line 44, :end-line 44, :max-fixed-arity 2, :fn-var true, :arglists ([] [kind] [kind id])}}, :require-macros nil, :cljs.analyzer/constants {:seen #{:sub :warn :event :error :cofx :fx}, :order [:sub :event :cofx :fx :error :warn]}, :doc "In many places, re-frame asks you to associate an `id` (keyword)\n with a `handler` (function). This namespace contains the\n central registry of such associations."}

151
resources/public/js/compiled/out/re_frame/registrar.js Normal file
View file

@ -0,0 +1,151 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.registrar');
goog.require('cljs.core');
goog.require('re_frame.interop');
goog.require('re_frame.loggers');
re_frame.registrar.kinds = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,"sub","sub",-2093760025),null,new cljs.core.Keyword(null,"event","event",301435442),null,new cljs.core.Keyword(null,"cofx","cofx",2013202907),null,new cljs.core.Keyword(null,"fx","fx",-1237829572),null], null), null);
re_frame.registrar.kind__GT_id__GT_handler = cljs.core.atom.call(null,cljs.core.PersistentArrayMap.EMPTY);
re_frame.registrar.get_handler = (function re_frame$registrar$get_handler(var_args){
var args32746 = [];
var len__26205__auto___32749 = arguments.length;
var i__26206__auto___32750 = (0);
while(true){
if((i__26206__auto___32750 < len__26205__auto___32749)){
args32746.push((arguments[i__26206__auto___32750]));
var G__32751 = (i__26206__auto___32750 + (1));
i__26206__auto___32750 = G__32751;
continue;
} else {
}
break;
}
var G__32748 = args32746.length;
switch (G__32748) {
case 1:
return re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
case 3:
return re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32746.length)].join('')));
}
});
re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$1 = (function (kind){
return cljs.core.get.call(null,cljs.core.deref.call(null,re_frame.registrar.kind__GT_id__GT_handler),kind);
});
re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$2 = (function (kind,id){
return cljs.core.get.call(null,cljs.core.get.call(null,cljs.core.deref.call(null,re_frame.registrar.kind__GT_id__GT_handler),kind),id);
});
re_frame.registrar.get_handler.cljs$core$IFn$_invoke$arity$3 = (function (kind,id,required_QMARK_){
var handler = re_frame.registrar.get_handler.call(null,kind,id);
if(re_frame.interop.debug_enabled_QMARK_){
if(cljs.core.truth_((function (){var and__25118__auto__ = required_QMARK_;
if(cljs.core.truth_(and__25118__auto__)){
return (handler == null);
} else {
return and__25118__auto__;
}
})())){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: no ",[cljs.core.str(kind)].join('')," handler registered for:",id);
} else {
}
} else {
}
return handler;
});
re_frame.registrar.get_handler.cljs$lang$maxFixedArity = 3;
re_frame.registrar.register_handler = (function re_frame$registrar$register_handler(kind,id,handler_fn){
if(re_frame.interop.debug_enabled_QMARK_){
if(cljs.core.truth_(re_frame.registrar.get_handler.call(null,kind,id,false))){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: overwriting",[cljs.core.str(kind)].join(''),"handler for:",id);
} else {
}
} else {
}
cljs.core.swap_BANG_.call(null,re_frame.registrar.kind__GT_id__GT_handler,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [kind,id], null),handler_fn);
return handler_fn;
});
re_frame.registrar.clear_handlers = (function re_frame$registrar$clear_handlers(var_args){
var args32753 = [];
var len__26205__auto___32756 = arguments.length;
var i__26206__auto___32757 = (0);
while(true){
if((i__26206__auto___32757 < len__26205__auto___32756)){
args32753.push((arguments[i__26206__auto___32757]));
var G__32758 = (i__26206__auto___32757 + (1));
i__26206__auto___32757 = G__32758;
continue;
} else {
}
break;
}
var G__32755 = args32753.length;
switch (G__32755) {
case 0:
return re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$0();
break;
case 1:
return re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
break;
case 2:
return re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
break;
default:
throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args32753.length)].join('')));
}
});
re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$0 = (function (){
return cljs.core.reset_BANG_.call(null,re_frame.registrar.kind__GT_id__GT_handler,cljs.core.PersistentArrayMap.EMPTY);
});
re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$1 = (function (kind){
if(cljs.core.truth_(re_frame.registrar.kinds.call(null,kind))){
} else {
throw (new Error("Assert failed: (kinds kind)"));
}
return cljs.core.swap_BANG_.call(null,re_frame.registrar.kind__GT_id__GT_handler,cljs.core.dissoc,kind);
});
re_frame.registrar.clear_handlers.cljs$core$IFn$_invoke$arity$2 = (function (kind,id){
if(cljs.core.truth_(re_frame.registrar.kinds.call(null,kind))){
} else {
throw (new Error("Assert failed: (kinds kind)"));
}
if(cljs.core.truth_(re_frame.registrar.get_handler.call(null,kind,id))){
return cljs.core.swap_BANG_.call(null,re_frame.registrar.kind__GT_id__GT_handler,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [kind], null),cljs.core.dissoc,id);
} else {
return re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: can't clear",[cljs.core.str(kind)].join(''),"handler for",[cljs.core.str(id),cljs.core.str(". Handler not found.")].join(''));
}
});
re_frame.registrar.clear_handlers.cljs$lang$maxFixedArity = 2;
//# sourceMappingURL=registrar.js.map?rel=1603199197656

1
resources/public/js/compiled/out/re_frame/registrar.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/registrar.js","sources":["registrar.cljc?rel=1603199197657"],"lineCount":151,"mappings":";AAAA;;;;AASA,2BAAA,iFAAA,yDAAA,2DAAA,0DAAA,1RAAKA;AAKL,AAAKC,6CAAmB,yBAAA,zBAACC;AAGzB,AAAA,iCAAA,yCAAAC,1EAAMK;AAAN,AAAA,IAAAJ,YAAA;AAAA,AAAA,IAAAC,2BAAA,AAAA;AAAA,AAAA,IAAAC,yBAAA;;AAAA,AAAA,GAAA,CAAAA,yBAAAD;AAAA,AAAA,AAAAD,eAAA,CAAA,UAAAE;;AAAA,eAAA,CAAAA,yBAAA;;;;AAAA;;;;AAAA,IAAAC,WAAA,AAAAH;AAAA,AAAA,QAAAG;KAAA;AAAA,OAAAC,6DAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,6DAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,6DAAA,CAAA,UAAA,MAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;;AAAA,MAAA,KAAAC,MAAA,eAAA,iCAAA,AAAAL;;;;;AAAA,AAAA,+DAAA,\/DAAMI,0EAEFE;AAFJ,AAGG,+BAAA,AAAAC,xBAACC,kDAAKX,4CAAkBS;;;AAH3B,AAAA,+DAAA,\/DAAMF,0EAKFE,KAAKG;AALT,+BAMO,wBAAA,AAAAF,xBAACC,kDAAKX,4CAAkBS,7HACxB,OAACE,4HAAIC;;;AAPZ,AAAA,+DAAA,\/DAAML,0EASFE,KAAKG,GAAGC;AATZ,AAUG,IAAMC,UAAQ,AAACP,yCAAYE,KAAKG;AAAhC,AACE,GAAMG;AAAN,AACE,oBAAM,iBAAAC,qBAAKH;AAAL,AAAA,oBAAAG;AAAe,mBAAA,XAAMF;;AAArBE;;;AAAN,AACE,mCAAA,uDAAA,+CAAA,zIAACC,0GAA+B,eAAKR,2CAAiCG;;AADxE;;AADF;;AAGAE;;;AAdL,AAAA,yDAAA,zDAAMP;;AAAN,AAiBA,sCAAA,tCAAMW,oFACHT,KAAKG,GAAGO;AADX,AAEE,GAAMJ;AAAN,AACE,oBAAM,iDAAA,jDAACR,yCAAYE,KAAKG;AAAxB,AACE,mCAAA,qDAAA,uDAAA,\/IAACK,gHAAsC,eAAKR,+BAAqBG;;AADnE;;AADF;;AAGA,6FAAA,7FAACQ,+BAAMpB,2CAAkBqB,sGAAUZ,KAAKG,WAAIO;;AAC5CA;;AAGF,AAAA,oCAAA,4CAAAjB,hFAAMsB;AAAN,AAAA,IAAAF,YAAA;AAAA,AAAA,IAAAlB,2BAAA,AAAA;AAAA,AAAA,IAAAC,yBAAA;;AAAA,AAAA,GAAA,CAAAA,yBAAAD;AAAA,AAAA,AAAAkB,eAAA,CAAA,UAAAjB;;AAAA,eAAA,CAAAA,yBAAA;;;;AAAA;;;;AAAA,IAAAkB,WAAA,AAAAD;AAAA,AAAA,QAAAC;KAAA;AAAA,OAAAC;;;KAAA;AAAA,OAAAA,gEAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,gEAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;;AAAA,MAAA,KAAAhB,MAAA,eAAA,iCAAA,AAAAc;;;;;AAAA,AAAA,kEAAA,lEAAME;AAAN,AAEG,kFAAA,3EAACC,gCAAOzB;;;AAFX,AAAA,kEAAA,lEAAMwB,6EAIFf;AAJJ,AAKG,oBAAQ,AAACV,mCAAMU;AAAf;AAAA,AAAA,MAAA,KAAAD,MAAA;;;AACA,OAACY,+BAAMpB,2CAAkB0B,iBAAOjB;;;AANnC,AAAA,kEAAA,lEAAMe,6EAQFf,KAAKG;AART,AASG,oBAAQ,AAACb,mCAAMU;AAAf;AAAA,AAAA,MAAA,KAAAD,MAAA;;;AACA,oBAAI,AAACD,yCAAYE,KAAKG;AACpB,qGAAA,9FAACQ,+BAAMpB,2CAAkB2B,uGAAWlB,aAAMiB,iBAAOd;;AACjD,0CAAA,qDAAA,uDAAA,\/IAACK,gHAAsC,eAAKR,8BAAoB,iCAAA,lBAAKG;;;;AAZ1E,AAAA,4DAAA,5DAAMY;;AAAN","names":["re-frame.registrar\/kinds","re-frame.registrar\/kind->id->handler","cljs.core\/atom","var_args","args32746","len__26205__auto__","i__26206__auto__","G__32748","re-frame.registrar\/get-handler","js\/Error","kind","cljs.core\/deref","cljs.core\/get","id","required?","handler","re-frame.interop\/debug-enabled?","and__25118__auto__","re-frame.loggers\/console","re-frame.registrar\/register-handler","handler-fn","cljs.core\/swap!","cljs.core\/assoc-in","args32753","G__32755","re-frame.registrar\/clear-handlers","cljs.core\/reset!","cljs.core\/dissoc","cljs.core\/update-in"]}

256
resources/public/js/compiled/out/re_frame/router.cljc Normal file
View file

@ -0,0 +1,256 @@
(ns re-frame.router
(:require [re-frame.events :refer [handle]]
[re-frame.interop :refer [after-render empty-queue next-tick]]
[re-frame.loggers :refer [console]]
[re-frame.trace :as trace :include-macros true]))
;; -- Router Loop ------------------------------------------------------------
;;
;; A call to "re-frame.core/dispatch" places an event on a queue for processing.
;; A short time later, the handler registered to handle this event will be run.
;; What follows is the implementation of this process.
;;
;; The task is to process queued events in a perpetual loop, one after
;; the other, FIFO, calling the registered event-handler for each, being idle when
;; there are no events, and firing up when one arrives.
;;
;; But browsers only have a single thread of control and we must be
;; careful to not hog the CPU. When processing events one after another, we
;; must regularly hand back control to the browser, so it can redraw, process
;; websockets, etc. But not too regularly! If we are in a de-focused browser
;; tab, our app will be CPU throttled. Each time we get back control, we have
;; to process all queued events, or else something like a bursty websocket
;; (producing events) might overwhelm the queue. So there's a balance.
;;
;; The processing/handling of an event happens "asynchronously" sometime after
;; that event was enqueued via "dispatch". The original implementation of this router loop
;; used `core.async`. As a result, it was fairly simple, and it mostly worked,
;; but it did not give enough control. So now we hand-roll our own,
;; finite-state-machine and all.
;;
;; In what follows, the strategy is this:
;; - maintain a FIFO queue of `dispatched` events.
;; - when a new event arrives, "schedule" processing of this queue using
;; goog.async.nextTick, which means it will happen "very soon".
;; - when processing events, one after the other, do ALL the currently
;; queued events. Don't stop. Don't yield to the browser. Hog that CPU.
;; - but if any new events are dispatched during this cycle of processing,
;; don't do them immediately. Leave them queued. Yield first to the browser,
;; and do these new events in the next processing cycle. That way we drain
;; the queue up to a point, but we never hog the CPU forever. In
;; particular, we handle the case where handling one event will beget
;; another event. The freshly begotten event will be handled next cycle,
;; with yielding in-between.
;; - In some cases, an event should not be handled until after the GUI has been
;; updated, i.e., after the next Reagent animation frame. In such a case,
;; the event should be dispatched with :flush-dom metadata like this:
;; (dispatch ^:flush-dom [:event-id other params])
;; Such an event will temporarily block all further processing because
;; events are processed sequentially: we handle one event completely
;; before we handle the ones behind it.
;;
;; Implementation notes:
;; - queue processing can be in a number of states: scheduled, running, paused
;; etc. So it is modeled as a Finite State Machine.
;; See "-fsm-trigger" (below) for the states and transitions.
;; - the scheduling is done via "goog.async.nextTick" which is pretty quick
;; - when the event has :flush-dom metadata we schedule via
;; "reagent.core.after-render"
;; which will run event processing after the next Reagent animation frame.
;;
;; Events can have metadata which says to pause event processing.
;; event metadata -> "run later" functions
(def later-fns
{:flush-dom (fn [f] (after-render #(next-tick f))) ;; one tick after the end of the next annimation frame
:yield next-tick}) ;; almost immediately
;; Event Queue Abstraction
(defprotocol IEventQueue
;; -- API
(push [this event])
(add-post-event-callback [this id callack])
(remove-post-event-callback [this f])
;; -- Implementation via a Finite State Machine
(-fsm-trigger [this trigger arg])
;; -- Finite State Machine actions
(-add-event [this event])
(-process-1st-event-in-queue [this])
(-run-next-tick [this])
(-run-queue [this])
(-exception [this ex])
(-pause [this later-fn])
(-resume [this])
(-call-post-event-callbacks [this event]))
;; Concrete implementation of IEventQueue
(deftype EventQueue [#?(:cljs ^:mutable fsm-state :clj ^:volatile-mutable fsm-state)
#?(:cljs ^:mutable queue :clj ^:volatile-mutable queue)
#?(:cljs ^:mutable post-event-callback-fns :clj ^:volatile-mutable post-event-callback-fns)]
IEventQueue
;; -- API ------------------------------------------------------------------
(push [this event] ;; presumably called by dispatch
(-fsm-trigger this :add-event event))
;; register a callback function which will be called after each event is processed
(add-post-event-callback [_ id callback-fn]
(if (contains? post-event-callback-fns id)
(console :warn "re-frame: overwriting existing post event call back with id:" id))
(->> (assoc post-event-callback-fns id callback-fn)
(set! post-event-callback-fns)))
(remove-post-event-callback [_ id]
(if-not (contains? post-event-callback-fns id)
(console :warn "re-frame: could not remove post event call back with id:" id)
(->> (dissoc post-event-callback-fns id)
(set! post-event-callback-fns))))
;; -- FSM Implementation ---------------------------------------------------
(-fsm-trigger
[this trigger arg]
;; The following "case" implements the Finite State Machine.
;; Given a "trigger", and the existing FSM state, it computes the
;; new FSM state and the transition action (function).
(trace/with-trace {:op-type ::fsm-trigger}
(let [[new-fsm-state action-fn]
(case [fsm-state trigger]
;; You should read the following "case" as:
;; [current-FSM-state trigger] -> [new-FSM-state action-fn]
;;
;; So, for example, the next line should be interpreted as:
;; if you are in state ":idle" and a trigger ":add-event"
;; happens, then move the FSM to state ":scheduled" and execute
;; that two-part "do" function.
[:idle :add-event] [:scheduled #(do (-add-event this arg)
(-run-next-tick this))]
;; State: :scheduled (the queue is scheduled to run, soon)
[:scheduled :add-event] [:scheduled #(-add-event this arg)]
[:scheduled :run-queue] [:running #(-run-queue this)]
;; State: :running (the queue is being processed one event after another)
[:running :add-event] [:running #(-add-event this arg)]
[:running :pause] [:paused #(-pause this arg)]
[:running :exception] [:idle #(-exception this arg)]
[:running :finish-run] (if (empty? queue) ;; FSM guard
[:idle]
[:scheduled #(-run-next-tick this)])
;; State: :paused (:flush-dom metadata on an event has caused a temporary pause in processing)
[:paused :add-event] [:paused #(-add-event this arg)]
[:paused :resume] [:running #(-resume this)]
(throw (ex-info (str "re-frame: router state transition not found. " fsm-state " " trigger)
{:fsm-state fsm-state, :trigger trigger})))]
;; The "case" above computed both the new FSM state, and the action. Now, make it happen.
(trace/merge-trace! {:operation [fsm-state trigger]
:tags {:current-state fsm-state
:new-state new-fsm-state}})
(set! fsm-state new-fsm-state)
(when action-fn (action-fn)))))
(-add-event
[_ event]
(set! queue (conj queue event)))
(-process-1st-event-in-queue
[this]
(let [event-v (peek queue)]
(try
(handle event-v)
(set! queue (pop queue))
(-call-post-event-callbacks this event-v)
(catch #?(:cljs :default :clj Exception) ex
(-fsm-trigger this :exception ex)))))
(-run-next-tick
[this]
(next-tick #(-fsm-trigger this :run-queue nil)))
;; Process all the events currently in the queue, but not any new ones.
;; Be aware that events might have metadata which will pause processing.
(-run-queue
[this]
(loop [n (count queue)]
(if (zero? n)
(-fsm-trigger this :finish-run nil)
(if-let [later-fn (some later-fns (-> queue peek meta keys))] ;; any metadata which causes pausing?
(-fsm-trigger this :pause later-fn)
(do (-process-1st-event-in-queue this)
(recur (dec n)))))))
(-exception
[_ ex]
(set! queue empty-queue) ;; purge the queue
(throw ex))
(-pause
[this later-fn]
(later-fn #(-fsm-trigger this :resume nil)))
(-call-post-event-callbacks
[_ event-v]
(doseq [callback (vals post-event-callback-fns)]
(callback event-v queue)))
(-resume
[this]
(-process-1st-event-in-queue this) ;; do the event which paused processing
(-run-queue this))) ;; do the rest of the queued events
;; ---------------------------------------------------------------------------
;; Event Queue
;; When "dispatch" is called, the event is added into this event queue. Later,
;; the queue will "run" and the event will be "handled" by the registered function.
;;
(def event-queue (->EventQueue :idle empty-queue {}))
;; ---------------------------------------------------------------------------
;; Dispatching
;;
(defn dispatch
"Queue the given event for processing by the registered event handler.
Just to be clear: the event handler is not run immediately - it is not run
synchronously. It will likely be run 'very soon', although it may be
added to the end of a FIFO queue which already contain events.
Usage:
(dispatch [:delete-item 42])"
[event]
(if (nil? event)
(throw (ex-info "re-frame: you called \"dispatch\" without an event vector." {}))
(push event-queue event))
nil) ;; Ensure nil return. See https://github.com/Day8/re-frame/wiki/Beware-Returning-False
(defn dispatch-sync
"Sychronously (immediately!) process the given event using the registered handler.
Generally, you shouldn't use this - you should use `dispatch` instead. It
is an error to use `dispatch-sync` within an event handler.
Usage:
(dispatch-sync [:delete-item 42])"
[event-v]
(handle event-v)
(-call-post-event-callbacks event-queue event-v) ;; slightly ugly hack. Run the registered post event callbacks.
nil) ;; Ensure nil return. See https://github.com/Day8/re-frame/wiki/Beware-Returning-False

1
resources/public/js/compiled/out/re_frame/router.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

759
resources/public/js/compiled/out/re_frame/router.js Normal file
View file

@ -0,0 +1,759 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.router');
goog.require('cljs.core');
goog.require('re_frame.events');
goog.require('re_frame.interop');
goog.require('re_frame.loggers');
goog.require('re_frame.trace');
re_frame.router.later_fns = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"flush-dom","flush-dom",-933676816),(function (f){
return re_frame.interop.after_render.call(null,(function (){
return re_frame.interop.next_tick.call(null,f);
}));
}),new cljs.core.Keyword(null,"yield","yield",177875009),re_frame.interop.next_tick], null);
/**
* @interface
*/
re_frame.router.IEventQueue = function(){};
re_frame.router.push = (function re_frame$router$push(this$,event){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$push$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$push$arity$2(this$,event);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router.push[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,event);
} else {
var m__25794__auto____$1 = (re_frame.router.push["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,event);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.push",this$);
}
}
}
});
re_frame.router.add_post_event_callback = (function re_frame$router$add_post_event_callback(this$,id,callack){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$add_post_event_callback$arity$3 == null)))){
return this$.re_frame$router$IEventQueue$add_post_event_callback$arity$3(this$,id,callack);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router.add_post_event_callback[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,id,callack);
} else {
var m__25794__auto____$1 = (re_frame.router.add_post_event_callback["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,id,callack);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.add-post-event-callback",this$);
}
}
}
});
re_frame.router.remove_post_event_callback = (function re_frame$router$remove_post_event_callback(this$,f){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$remove_post_event_callback$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$remove_post_event_callback$arity$2(this$,f);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router.remove_post_event_callback[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,f);
} else {
var m__25794__auto____$1 = (re_frame.router.remove_post_event_callback["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,f);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.remove-post-event-callback",this$);
}
}
}
});
re_frame.router._fsm_trigger = (function re_frame$router$_fsm_trigger(this$,trigger,arg){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_fsm_trigger$arity$3 == null)))){
return this$.re_frame$router$IEventQueue$_fsm_trigger$arity$3(this$,trigger,arg);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._fsm_trigger[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,trigger,arg);
} else {
var m__25794__auto____$1 = (re_frame.router._fsm_trigger["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,trigger,arg);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-fsm-trigger",this$);
}
}
}
});
re_frame.router._add_event = (function re_frame$router$_add_event(this$,event){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_add_event$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$_add_event$arity$2(this$,event);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._add_event[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,event);
} else {
var m__25794__auto____$1 = (re_frame.router._add_event["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,event);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-add-event",this$);
}
}
}
});
re_frame.router._process_1st_event_in_queue = (function re_frame$router$_process_1st_event_in_queue(this$){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_process_1st_event_in_queue$arity$1 == null)))){
return this$.re_frame$router$IEventQueue$_process_1st_event_in_queue$arity$1(this$);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._process_1st_event_in_queue[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$);
} else {
var m__25794__auto____$1 = (re_frame.router._process_1st_event_in_queue["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-process-1st-event-in-queue",this$);
}
}
}
});
re_frame.router._run_next_tick = (function re_frame$router$_run_next_tick(this$){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_run_next_tick$arity$1 == null)))){
return this$.re_frame$router$IEventQueue$_run_next_tick$arity$1(this$);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._run_next_tick[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$);
} else {
var m__25794__auto____$1 = (re_frame.router._run_next_tick["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-run-next-tick",this$);
}
}
}
});
re_frame.router._run_queue = (function re_frame$router$_run_queue(this$){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_run_queue$arity$1 == null)))){
return this$.re_frame$router$IEventQueue$_run_queue$arity$1(this$);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._run_queue[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$);
} else {
var m__25794__auto____$1 = (re_frame.router._run_queue["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-run-queue",this$);
}
}
}
});
re_frame.router._exception = (function re_frame$router$_exception(this$,ex){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_exception$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$_exception$arity$2(this$,ex);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._exception[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,ex);
} else {
var m__25794__auto____$1 = (re_frame.router._exception["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,ex);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-exception",this$);
}
}
}
});
re_frame.router._pause = (function re_frame$router$_pause(this$,later_fn){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_pause$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$_pause$arity$2(this$,later_fn);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._pause[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,later_fn);
} else {
var m__25794__auto____$1 = (re_frame.router._pause["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,later_fn);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-pause",this$);
}
}
}
});
re_frame.router._resume = (function re_frame$router$_resume(this$){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_resume$arity$1 == null)))){
return this$.re_frame$router$IEventQueue$_resume$arity$1(this$);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._resume[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$);
} else {
var m__25794__auto____$1 = (re_frame.router._resume["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-resume",this$);
}
}
}
});
re_frame.router._call_post_event_callbacks = (function re_frame$router$_call_post_event_callbacks(this$,event){
if((!((this$ == null))) && (!((this$.re_frame$router$IEventQueue$_call_post_event_callbacks$arity$2 == null)))){
return this$.re_frame$router$IEventQueue$_call_post_event_callbacks$arity$2(this$,event);
} else {
var x__25793__auto__ = (((this$ == null))?null:this$);
var m__25794__auto__ = (re_frame.router._call_post_event_callbacks[goog.typeOf(x__25793__auto__)]);
if(!((m__25794__auto__ == null))){
return m__25794__auto__.call(null,this$,event);
} else {
var m__25794__auto____$1 = (re_frame.router._call_post_event_callbacks["_"]);
if(!((m__25794__auto____$1 == null))){
return m__25794__auto____$1.call(null,this$,event);
} else {
throw cljs.core.missing_protocol.call(null,"IEventQueue.-call-post-event-callbacks",this$);
}
}
}
});
/**
* @constructor
* @implements {re_frame.router.IEventQueue}
*/
re_frame.router.EventQueue = (function (fsm_state,queue,post_event_callback_fns){
this.fsm_state = fsm_state;
this.queue = queue;
this.post_event_callback_fns = post_event_callback_fns;
})
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$ = true;
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_run_queue$arity$1 = (function (this$){
var self__ = this;
var this$__$1 = this;
var n = cljs.core.count.call(null,self__.queue);
while(true){
if((n === (0))){
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"finish-run","finish-run",753148477),null);
} else {
var temp__4655__auto__ = cljs.core.some.call(null,re_frame.router.later_fns,cljs.core.keys.call(null,cljs.core.meta.call(null,cljs.core.peek.call(null,self__.queue))));
if(cljs.core.truth_(temp__4655__auto__)){
var later_fn = temp__4655__auto__;
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"pause","pause",-2095325672),later_fn);
} else {
re_frame.router._process_1st_event_in_queue.call(null,this$__$1);
var G__32861 = (n - (1));
n = G__32861;
continue;
}
}
break;
}
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$remove_post_event_callback$arity$2 = (function (_,id){
var self__ = this;
var ___$1 = this;
if(!(cljs.core.contains_QMARK_.call(null,self__.post_event_callback_fns,id))){
return re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: could not remove post event call back with id:",id);
} else {
return self__.post_event_callback_fns = cljs.core.dissoc.call(null,self__.post_event_callback_fns,id);
}
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_add_event$arity$2 = (function (_,event){
var self__ = this;
var ___$1 = this;
return self__.queue = cljs.core.conj.call(null,self__.queue,event);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_resume$arity$1 = (function (this$){
var self__ = this;
var this$__$1 = this;
re_frame.router._process_1st_event_in_queue.call(null,this$__$1);
return re_frame.router._run_queue.call(null,this$__$1);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$push$arity$2 = (function (this$,event){
var self__ = this;
var this$__$1 = this;
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"add-event","add-event",938429088),event);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_run_next_tick$arity$1 = (function (this$){
var self__ = this;
var this$__$1 = this;
return re_frame.interop.next_tick.call(null,((function (this$__$1){
return (function (){
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"run-queue","run-queue",-1701798027),null);
});})(this$__$1))
);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_fsm_trigger$arity$3 = (function (this$,trigger,arg){
var self__ = this;
var this$__$1 = this;
if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var _STAR_current_trace_STAR_32835 = re_frame.trace._STAR_current_trace_STAR_;
re_frame.trace._STAR_current_trace_STAR_ = re_frame.trace.start_trace.call(null,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"op-type","op-type",-1636141668),new cljs.core.Keyword("re-frame.router","fsm-trigger","re-frame.router/fsm-trigger",1379787274)], null));
try{try{var vec__32848 = (function (){var G__32851 = new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null);
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
re_frame.router._add_event.call(null,this$__$1,arg);
return re_frame.router._run_next_tick.call(null,this$__$1);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),new cljs.core.Keyword(null,"run-queue","run-queue",-1701798027)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._run_queue.call(null,this$__$1);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"pause","pause",-2095325672)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._pause.call(null,this$__$1,arg);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"exception","exception",-335277064)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._exception.call(null,this$__$1,arg);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"finish-run","finish-run",753148477)], null),G__32851)){
if(cljs.core.empty_QMARK_.call(null,self__.queue)){
return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861)], null);
} else {
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._run_next_tick.call(null,this$__$1);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
}
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),new cljs.core.Keyword(null,"resume","resume",-118572261)], null),G__32851)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32851,_STAR_current_trace_STAR_32835,this$__$1){
return (function (){
return re_frame.router._resume.call(null,this$__$1);
});})(G__32851,_STAR_current_trace_STAR_32835,this$__$1))
], null);
} else {
throw cljs.core.ex_info.call(null,[cljs.core.str("re-frame: router state transition not found. "),cljs.core.str(self__.fsm_state),cljs.core.str(" "),cljs.core.str(trigger)].join(''),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"fsm-state","fsm-state",1656310533),self__.fsm_state,new cljs.core.Keyword(null,"trigger","trigger",103466139),trigger], null));
}
}
}
}
}
}
}
}
}
})();
var new_fsm_state = cljs.core.nth.call(null,vec__32848,(0),null);
var action_fn = cljs.core.nth.call(null,vec__32848,(1),null);
if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var new_trace__32713__auto___32862 = cljs.core.merge.call(null,cljs.core.update.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"tags","tags",1771418977),cljs.core.merge,new cljs.core.Keyword(null,"tags","tags",1771418977).cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"operation","operation",-1267664310),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null),new cljs.core.Keyword(null,"tags","tags",1771418977),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"current-state","current-state",1048284452),self__.fsm_state,new cljs.core.Keyword(null,"new-state","new-state",-490349212),new_fsm_state], null)], null))),cljs.core.dissoc.call(null,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"operation","operation",-1267664310),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null),new cljs.core.Keyword(null,"tags","tags",1771418977),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"current-state","current-state",1048284452),self__.fsm_state,new cljs.core.Keyword(null,"new-state","new-state",-490349212),new_fsm_state], null)], null),new cljs.core.Keyword(null,"tags","tags",1771418977)));
re_frame.trace._STAR_current_trace_STAR_ = new_trace__32713__auto___32862;
} else {
}
self__.fsm_state = new_fsm_state;
if(cljs.core.truth_(action_fn)){
return action_fn.call(null);
} else {
return null;
}
}finally {if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var end__32708__auto___32863 = re_frame.interop.now.call(null);
var duration__32709__auto___32864 = (end__32708__auto___32863 - new cljs.core.Keyword(null,"start","start",-355208981).cljs$core$IFn$_invoke$arity$1(re_frame.trace._STAR_current_trace_STAR_));
var seq__32836_32865 = cljs.core.seq.call(null,cljs.core.deref.call(null,re_frame.trace.trace_cbs));
var chunk__32837_32866 = null;
var count__32838_32867 = (0);
var i__32839_32868 = (0);
while(true){
if((i__32839_32868 < count__32838_32867)){
var vec__32840_32869 = cljs.core._nth.call(null,chunk__32837_32866,i__32839_32868);
var k__32710__auto___32870 = cljs.core.nth.call(null,vec__32840_32869,(0),null);
var cb__32711__auto___32871 = cljs.core.nth.call(null,vec__32840_32869,(1),null);
try{cb__32711__auto___32871.call(null,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.assoc.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"duration","duration",1444101068),duration__32709__auto___32864,new cljs.core.Keyword(null,"end","end",-268185958),re_frame.interop.now.call(null))], null));
}catch (e32843){if((e32843 instanceof java.lang.Exception)){
var e__32712__auto___32872 = e32843;
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"Error thrown from trace cb",k__32710__auto___32870,"while storing",re_frame.trace._STAR_current_trace_STAR_,e__32712__auto___32872);
} else {
throw e32843;
}
}
var G__32873 = seq__32836_32865;
var G__32874 = chunk__32837_32866;
var G__32875 = count__32838_32867;
var G__32876 = (i__32839_32868 + (1));
seq__32836_32865 = G__32873;
chunk__32837_32866 = G__32874;
count__32838_32867 = G__32875;
i__32839_32868 = G__32876;
continue;
} else {
var temp__4657__auto___32877 = cljs.core.seq.call(null,seq__32836_32865);
if(temp__4657__auto___32877){
var seq__32836_32878__$1 = temp__4657__auto___32877;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32836_32878__$1)){
var c__25941__auto___32879 = cljs.core.chunk_first.call(null,seq__32836_32878__$1);
var G__32880 = cljs.core.chunk_rest.call(null,seq__32836_32878__$1);
var G__32881 = c__25941__auto___32879;
var G__32882 = cljs.core.count.call(null,c__25941__auto___32879);
var G__32883 = (0);
seq__32836_32865 = G__32880;
chunk__32837_32866 = G__32881;
count__32838_32867 = G__32882;
i__32839_32868 = G__32883;
continue;
} else {
var vec__32844_32884 = cljs.core.first.call(null,seq__32836_32878__$1);
var k__32710__auto___32885 = cljs.core.nth.call(null,vec__32844_32884,(0),null);
var cb__32711__auto___32886 = cljs.core.nth.call(null,vec__32844_32884,(1),null);
try{cb__32711__auto___32886.call(null,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.assoc.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"duration","duration",1444101068),duration__32709__auto___32864,new cljs.core.Keyword(null,"end","end",-268185958),re_frame.interop.now.call(null))], null));
}catch (e32847){if((e32847 instanceof java.lang.Exception)){
var e__32712__auto___32887 = e32847;
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"Error thrown from trace cb",k__32710__auto___32885,"while storing",re_frame.trace._STAR_current_trace_STAR_,e__32712__auto___32887);
} else {
throw e32847;
}
}
var G__32888 = cljs.core.next.call(null,seq__32836_32878__$1);
var G__32889 = null;
var G__32890 = (0);
var G__32891 = (0);
seq__32836_32865 = G__32888;
chunk__32837_32866 = G__32889;
count__32838_32867 = G__32890;
i__32839_32868 = G__32891;
continue;
}
} else {
}
}
break;
}
} else {
}
}}finally {re_frame.trace._STAR_current_trace_STAR_ = _STAR_current_trace_STAR_32835;
}} else {
var vec__32852 = (function (){var G__32855 = new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null);
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32855,this$__$1){
return (function (){
re_frame.router._add_event.call(null,this$__$1,arg);
return re_frame.router._run_next_tick.call(null,this$__$1);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),new cljs.core.Keyword(null,"run-queue","run-queue",-1701798027)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._run_queue.call(null,this$__$1);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"pause","pause",-2095325672)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._pause.call(null,this$__$1,arg);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"exception","exception",-335277064)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._exception.call(null,this$__$1,arg);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),new cljs.core.Keyword(null,"finish-run","finish-run",753148477)], null),G__32855)){
if(cljs.core.empty_QMARK_.call(null,self__.queue)){
return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"idle","idle",-2007156861)], null);
} else {
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"scheduled","scheduled",553898551),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._run_next_tick.call(null,this$__$1);
});})(G__32855,this$__$1))
], null);
}
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),new cljs.core.Keyword(null,"add-event","add-event",938429088)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._add_event.call(null,this$__$1,arg);
});})(G__32855,this$__$1))
], null);
} else {
if(cljs.core._EQ_.call(null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"paused","paused",-1710376127),new cljs.core.Keyword(null,"resume","resume",-118572261)], null),G__32855)){
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"running","running",1554969103),((function (G__32855,this$__$1){
return (function (){
return re_frame.router._resume.call(null,this$__$1);
});})(G__32855,this$__$1))
], null);
} else {
throw cljs.core.ex_info.call(null,[cljs.core.str("re-frame: router state transition not found. "),cljs.core.str(self__.fsm_state),cljs.core.str(" "),cljs.core.str(trigger)].join(''),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"fsm-state","fsm-state",1656310533),self__.fsm_state,new cljs.core.Keyword(null,"trigger","trigger",103466139),trigger], null));
}
}
}
}
}
}
}
}
}
})();
var new_fsm_state = cljs.core.nth.call(null,vec__32852,(0),null);
var action_fn = cljs.core.nth.call(null,vec__32852,(1),null);
if(re_frame.trace.is_trace_enabled_QMARK_.call(null)){
var new_trace__32713__auto___32892 = cljs.core.merge.call(null,cljs.core.update.call(null,re_frame.trace._STAR_current_trace_STAR_,new cljs.core.Keyword(null,"tags","tags",1771418977),cljs.core.merge,new cljs.core.Keyword(null,"tags","tags",1771418977).cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"operation","operation",-1267664310),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null),new cljs.core.Keyword(null,"tags","tags",1771418977),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"current-state","current-state",1048284452),self__.fsm_state,new cljs.core.Keyword(null,"new-state","new-state",-490349212),new_fsm_state], null)], null))),cljs.core.dissoc.call(null,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"operation","operation",-1267664310),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.fsm_state,trigger], null),new cljs.core.Keyword(null,"tags","tags",1771418977),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"current-state","current-state",1048284452),self__.fsm_state,new cljs.core.Keyword(null,"new-state","new-state",-490349212),new_fsm_state], null)], null),new cljs.core.Keyword(null,"tags","tags",1771418977)));
re_frame.trace._STAR_current_trace_STAR_ = new_trace__32713__auto___32892;
} else {
}
self__.fsm_state = new_fsm_state;
if(cljs.core.truth_(action_fn)){
return action_fn.call(null);
} else {
return null;
}
}
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_pause$arity$2 = (function (this$,later_fn){
var self__ = this;
var this$__$1 = this;
return later_fn.call(null,((function (this$__$1){
return (function (){
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"resume","resume",-118572261),null);
});})(this$__$1))
);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$add_post_event_callback$arity$3 = (function (_,id,callback_fn){
var self__ = this;
var ___$1 = this;
if(cljs.core.contains_QMARK_.call(null,self__.post_event_callback_fns,id)){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"warn","warn",-436710552),"re-frame: overwriting existing post event call back with id:",id);
} else {
}
return self__.post_event_callback_fns = cljs.core.assoc.call(null,self__.post_event_callback_fns,id,callback_fn);
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_process_1st_event_in_queue$arity$1 = (function (this$){
var self__ = this;
var this$__$1 = this;
var event_v = cljs.core.peek.call(null,self__.queue);
try{re_frame.events.handle.call(null,event_v);
self__.queue = cljs.core.pop.call(null,self__.queue);
return re_frame.router._call_post_event_callbacks.call(null,this$__$1,event_v);
}catch (e32856){var ex = e32856;
return re_frame.router._fsm_trigger.call(null,this$__$1,new cljs.core.Keyword(null,"exception","exception",-335277064),ex);
}});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_call_post_event_callbacks$arity$2 = (function (_,event_v){
var self__ = this;
var ___$1 = this;
var seq__32857 = cljs.core.seq.call(null,cljs.core.vals.call(null,self__.post_event_callback_fns));
var chunk__32858 = null;
var count__32859 = (0);
var i__32860 = (0);
while(true){
if((i__32860 < count__32859)){
var callback = cljs.core._nth.call(null,chunk__32858,i__32860);
callback.call(null,event_v,self__.queue);
var G__32893 = seq__32857;
var G__32894 = chunk__32858;
var G__32895 = count__32859;
var G__32896 = (i__32860 + (1));
seq__32857 = G__32893;
chunk__32858 = G__32894;
count__32859 = G__32895;
i__32860 = G__32896;
continue;
} else {
var temp__4657__auto__ = cljs.core.seq.call(null,seq__32857);
if(temp__4657__auto__){
var seq__32857__$1 = temp__4657__auto__;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__32857__$1)){
var c__25941__auto__ = cljs.core.chunk_first.call(null,seq__32857__$1);
var G__32897 = cljs.core.chunk_rest.call(null,seq__32857__$1);
var G__32898 = c__25941__auto__;
var G__32899 = cljs.core.count.call(null,c__25941__auto__);
var G__32900 = (0);
seq__32857 = G__32897;
chunk__32858 = G__32898;
count__32859 = G__32899;
i__32860 = G__32900;
continue;
} else {
var callback = cljs.core.first.call(null,seq__32857__$1);
callback.call(null,event_v,self__.queue);
var G__32901 = cljs.core.next.call(null,seq__32857__$1);
var G__32902 = null;
var G__32903 = (0);
var G__32904 = (0);
seq__32857 = G__32901;
chunk__32858 = G__32902;
count__32859 = G__32903;
i__32860 = G__32904;
continue;
}
} else {
return null;
}
}
break;
}
});
re_frame.router.EventQueue.prototype.re_frame$router$IEventQueue$_exception$arity$2 = (function (_,ex){
var self__ = this;
var ___$1 = this;
self__.queue = re_frame.interop.empty_queue;
throw ex;
});
re_frame.router.EventQueue.getBasis = (function (){
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,"fsm-state","fsm-state",-998125236,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"mutable","mutable",875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,"queue","queue",-1198599890,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"mutable","mutable",875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,"post-event-callback-fns","post-event-callback-fns",-297038335,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"mutable","mutable",875778266),true], null))], null);
});
re_frame.router.EventQueue.cljs$lang$type = true;
re_frame.router.EventQueue.cljs$lang$ctorStr = "re-frame.router/EventQueue";
re_frame.router.EventQueue.cljs$lang$ctorPrWriter = (function (this__25736__auto__,writer__25737__auto__,opt__25738__auto__){
return cljs.core._write.call(null,writer__25737__auto__,"re-frame.router/EventQueue");
});
re_frame.router.__GT_EventQueue = (function re_frame$router$__GT_EventQueue(fsm_state,queue,post_event_callback_fns){
return (new re_frame.router.EventQueue(fsm_state,queue,post_event_callback_fns));
});
re_frame.router.event_queue = re_frame.router.__GT_EventQueue.call(null,new cljs.core.Keyword(null,"idle","idle",-2007156861),re_frame.interop.empty_queue,cljs.core.PersistentArrayMap.EMPTY);
/**
* Queue the given event for processing by the registered event handler.
*
* Just to be clear: the event handler is not run immediately - it is not run
* synchronously. It will likely be run 'very soon', although it may be
* added to the end of a FIFO queue which already contain events.
*
* Usage:
* (dispatch [:delete-item 42])
*/
re_frame.router.dispatch = (function re_frame$router$dispatch(event){
if((event == null)){
throw cljs.core.ex_info.call(null,"re-frame: you called \"dispatch\" without an event vector.",cljs.core.PersistentArrayMap.EMPTY);
} else {
re_frame.router.push.call(null,re_frame.router.event_queue,event);
}
return null;
});
/**
* Sychronously (immediately!) process the given event using the registered handler.
*
* Generally, you shouldn't use this - you should use `dispatch` instead. It
* is an error to use `dispatch-sync` within an event handler.
*
* Usage:
* (dispatch-sync [:delete-item 42])
*/
re_frame.router.dispatch_sync = (function re_frame$router$dispatch_sync(event_v){
re_frame.events.handle.call(null,event_v);
re_frame.router._call_post_event_callbacks.call(null,re_frame.router.event_queue,event_v);
return null;
});
//# sourceMappingURL=router.js.map?rel=1603199198008

1
resources/public/js/compiled/out/re_frame/router.js.map Normal file
View file

File diff suppressed because one or more lines are too long

304
resources/public/js/compiled/out/re_frame/std_interceptors.cljc Normal file
View file

@ -0,0 +1,304 @@
(ns re-frame.std-interceptors
"contains re-frame supplied, standard interceptors"
(:require
[re-frame.interceptor :refer [->interceptor get-effect get-coeffect assoc-coeffect assoc-effect]]
[re-frame.loggers :refer [console]]
[re-frame.registrar :as registrar]
[re-frame.db :refer [app-db]]
[clojure.data :as data]
[re-frame.cofx :as cofx]
[re-frame.utils :as utils]))
;; XXX provide a way to set what handler should be called when there is no registered handler.
;; by default this handler will simply print out a message saying no handler was found.
(def debug
"An interceptor which logs data about the handling of an event.
Includes a `clojure.data/diff` of the db, before vs after, showing
the changes caused by the event handler.
You'd typically want this interceptor after (to the right of) any
path interceptor.
Warning: calling clojure.data/diff on large, complex data structures
can be slow. So, you won't want this interceptor present in production
code. See the todomvc example to see how to exclude interceptors from
production code."
(->interceptor
:id :debug
:before (fn debug-before
[context]
(console :log "Handling re-frame event:" (get-coeffect context :event))
context)
:after (fn debug-after
[context]
(let [event (get-coeffect context :event)
orig-db (get-coeffect context :db)
new-db (get-effect context :db ::not-found)]
(if (= new-db ::not-found)
(console :log "No :db changes caused by:" event)
(let [[only-before only-after] (data/diff orig-db new-db)
db-changed? (or (some? only-before) (some? only-after))]
(if db-changed?
(do (console :group "db clojure.data/diff for:" event)
(console :log "only before:" only-before)
(console :log "only after :" only-after)
(console :groupEnd))
(console :log "no app-db changes caused by:" event))))
context))))
(def trim-v
"An interceptor which removes the first element of the event vector,
allowing you to write more aesthetically pleasing db handlers. No
leading underscore on the event-v!
Your event handlers will look like this:
(defn my-handler
[db [x y z]] ;; <-- instead of [_ x y z]
....)"
(->interceptor
:id :trim-v
:before (fn trimv-before
[context]
(-> context
(update-in [:coeffects :event] subvec 1)
(assoc-in [:coeffects ::untrimmed-event] (get-coeffect context :event))))
:after (fn trimv-after
[context]
(-> context
(utils/dissoc-in [:coeffects ::untrimmed-event])
(assoc-in [:coeffects :event] (get-coeffect context ::untrimmed-event))))))
;; -- Interceptor Factories - PART 1 ---------------------------------------------------------------
;;
;; These 3 factories wrap the 3 kinds of handlers.
;;
(defn db-handler->interceptor
"Returns an interceptor which wraps the kind of event handler given to `reg-event-db`.
These handlers take two arguments; `db` and `event`, and they return `db`.
(fn [db event]
....)
So, the interceptor wraps the given handler:
1. extracts two `:coeffects` keys: db and event
2. calls handler-fn
3. stores the db result back into context's `:effects`"
[handler-fn]
(->interceptor
:id :db-handler
:before (fn db-handler-before
[context]
(let [{:keys [db event]} (:coeffects context)]
(->> (handler-fn db event)
(assoc-effect context :db))))))
(defn fx-handler->interceptor
"Returns an interceptor which wraps the kind of event handler given to `reg-event-fx`.
These handlers take two arguments; `coeffects` and `event`, and they return `effects`.
(fn [coeffects event]
{:db ...
:dispatch ...})
Wrap handler in an interceptor so it can be added to (the RHS) of a chain:
1. extracts `:coeffects`
2. call handler-fn giving coeffects
3. stores the result back into the `:effects`"
[handler-fn]
(->interceptor
:id :fx-handler
:before (fn fx-handler-before
[context]
(let [{:keys [event] :as coeffects} (:coeffects context)]
(->> (handler-fn coeffects event)
(assoc context :effects))))))
(defn ctx-handler->interceptor
"Returns an interceptor which wraps the kind of event handler given to `reg-event-ctx`.
These advanced handlers take one argument: `context` and they return a modified `context`.
Example:
(fn [context]
(enqueue context [more interceptors]))"
[handler-fn]
(->interceptor
:id :ctx-handler
:before handler-fn))
;; -- Interceptors Factories - PART 2 ------------------------------------------------------------
(defn path
"An interceptor factory which supplies a sub-path of `:db` to the handler.
It's action is somewhat analogous to `update-in`. It grafts the return
value from the handler back into db.
Usage:
(path :some :path)
(path [:some :path])
(path [:some :path] :to :here)
(path [:some :path] [:to] :here)
Notes:
1. cater for `path` appearing more than once in an interceptor chain.
2. `:effects` may not contain `:db` effect. Which means no change to
`:db` should be made.
"
[& args]
(let [path (flatten args)
db-store-key :re-frame-path/db-store] ;; this is where, within `context`, we store the original dbs
(when (empty? path)
(console :error "re-frame: \"path\" interceptor given no params"))
(->interceptor
:id :path
:before (fn
[context]
(let [original-db (get-coeffect context :db)]
(-> context
(update db-store-key conj original-db)
(assoc-coeffect :db (get-in original-db path)))))
:after (fn [context]
(let [db-store (db-store-key context)
original-db (peek db-store)
new-db-store (pop db-store)
context' (-> (assoc context db-store-key new-db-store)
(assoc-coeffect :db original-db)) ;; put the original db back so that things like debug work later on
db (get-effect context :db ::not-found)]
(if (= db ::not-found)
context'
(->> (assoc-in original-db path db)
(assoc-effect context' :db))))))))
(defn enrich
"Interceptor factory which runs the given function `f` in the `after handler`
position. `f` is called with two arguments: `db` and `v`, and is expected to
return a modified `db`.
Unlike the `after` inteceptor which is only about side effects, `enrich`
expects `f` to process and alter the given `db` coeffect in some useful way,
contributing to the derived data, flowing vibe.
Example Use:
------------
Imagine that todomvc needed to do duplicate detection - if any two todos had
the same text, then highlight their background, and report them in a warning
down the bottom of the panel.
Almost any user action (edit text, add new todo, remove a todo) requires a
complete reassesment of duplication errors and warnings. Eg: that edit
just made might have introduced a new duplicate, or removed one. Same with
any todo removal. So we need to re-calculate warnings after any CRUD events
associated with the todos list.
Unless we are careful, we might end up coding subtly different checks
for each kind of CRUD operation. The duplicates check made after
'delete todo' event might be subtly different to that done after an
eddting operation. Nice and efficient, but fiddly. A bug generator
approach.
So, instead, we create an `f` which recalcualtes warnings from scratch
every time there is ANY change. It will inspect all the todos, and
reset ALL FLAGS every time (overwriting what was there previously)
and fully recalculate the list of duplicates (displayed at the bottom?).
By applying `f` in an `:enrich` interceptor, after every CRUD event,
we keep the handlers simple and yet we ensure this important step
(of getting warnings right) is not missed on any change.
We can test `f` easily - it is a pure fucntions - independently of
any CRUD operation.
This brings huge simplicity at the expense of some re-computation
each time. This may be a very satisfactory tradeoff in many cases."
[f]
(->interceptor
:id :enrich
:after (fn enrich-after
[context]
(let [event (get-coeffect context :event)
db (or (get-effect context :db)
;; If no db effect is returned, we provide the original coeffect.
(get-coeffect context :db))]
(->> (f db event)
(assoc-effect context :db))))))
(defn after
"Interceptor factory which runs a given function `f` in the \"after\"
position, presumably for side effects.
`f` is called with two arguments: the `effects` value of `:db`
(or the `coeffect` value of db if no db effect is returned) and the event.
Its return value is ignored so `f` can only side-effect.
Example use:
- `f` runs schema validation (reporting any errors found)
- `f` writes some aspect of db to localstorage."
[f]
(->interceptor
:id :after
:after (fn after-after
[context]
(let [db (or (get-effect context :db)
;; If no db effect is returned, we provide the original coeffect.
(get-coeffect context :db))
event (get-coeffect context :event)]
(f db event) ;; call f for side effects
context)))) ;; context is unchanged
(defn on-changes
"Interceptor factory which acts a bit like `reaction` (but it flows into `db`, rather than out)
It observes N paths in `db` and if any of them test not indentical? to their previous value
(as a result of a handler being run) then it runs `f` to compute a new value, which is
then assoced into the given `out-path` within `db`.
Usage:
(defn my-f
[a-val b-val]
... some computation on a and b in here)
(on-changes my-f [:c] [:a] [:b])
Put this Interceptor on the right handlers (ones which might change :a or :b).
It will:
- call `f` each time the value at path [:a] or [:b] changes
- call `f` with the values extracted from [:a] [:b]
- assoc the return value from `f` into the path [:c]
"
[f out-path & in-paths]
(->interceptor
:id :on-changes
:after (fn on-change-after
[context]
(let [new-db (get-effect context :db)
old-db (get-coeffect context :db)
;; work out if any "inputs" have changed
new-ins (map #(get-in new-db %) in-paths)
old-ins (map #(get-in old-db %) in-paths)
changed-ins? (some false? (map identical? new-ins old-ins))]
;; if one of the inputs has changed, then run 'f'
(if changed-ins?
(->> (apply f new-ins)
(assoc-in new-db out-path)
(assoc-effect context :db))
context)))))

1
resources/public/js/compiled/out/re_frame/std_interceptors.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

355
resources/public/js/compiled/out/re_frame/std_interceptors.js Normal file
View file

@ -0,0 +1,355 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.std_interceptors');
goog.require('cljs.core');
goog.require('re_frame.cofx');
goog.require('re_frame.interceptor');
goog.require('clojure.data');
goog.require('re_frame.registrar');
goog.require('re_frame.utils');
goog.require('re_frame.loggers');
goog.require('re_frame.db');
/**
* An interceptor which logs data about the handling of an event.
*
* Includes a `clojure.data/diff` of the db, before vs after, showing
* the changes caused by the event handler.
*
* You'd typically want this interceptor after (to the right of) any
* path interceptor.
*
* Warning: calling clojure.data/diff on large, complex data structures
* can be slow. So, you won't want this interceptor present in production
* code. See the todomvc example to see how to exclude interceptors from
* production code.
*/
re_frame.std_interceptors.debug = re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"debug","debug",-1608172596),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$std_interceptors$debug_before(context){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"log","log",-1595516004),"Handling re-frame event:",re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"event","event",301435442)));
return context;
}),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$std_interceptors$debug_after(context){
var event = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"event","event",301435442));
var orig_db = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
var new_db = re_frame.interceptor.get_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759),new cljs.core.Keyword("re-frame.std-interceptors","not-found","re-frame.std-interceptors/not-found",-1614827865));
if(cljs.core._EQ_.call(null,new_db,new cljs.core.Keyword("re-frame.std-interceptors","not-found","re-frame.std-interceptors/not-found",-1614827865))){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"log","log",-1595516004),"No :db changes caused by:",event);
} else {
var vec__33037_33040 = clojure.data.diff.call(null,orig_db,new_db);
var only_before_33041 = cljs.core.nth.call(null,vec__33037_33040,(0),null);
var only_after_33042 = cljs.core.nth.call(null,vec__33037_33040,(1),null);
var db_changed_QMARK__33043 = (cljs.core.some_QMARK_.call(null,only_before_33041)) || (cljs.core.some_QMARK_.call(null,only_after_33042));
if(db_changed_QMARK__33043){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"group","group",582596132),"db clojure.data/diff for:",event);
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"log","log",-1595516004),"only before:",only_before_33041);
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"log","log",-1595516004),"only after :",only_after_33042);
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"groupEnd","groupEnd",-337721382));
} else {
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"log","log",-1595516004),"no app-db changes caused by:",event);
}
}
return context;
}));
/**
* An interceptor which removes the first element of the event vector,
* allowing you to write more aesthetically pleasing db handlers. No
* leading underscore on the event-v!
* Your event handlers will look like this:
*
* (defn my-handler
* [db [x y z]] ;; <-- instead of [_ x y z]
* ....)
*/
re_frame.std_interceptors.trim_v = re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"trim-v","trim-v",-1274938640),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$std_interceptors$trimv_before(context){
return cljs.core.assoc_in.call(null,cljs.core.update_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword(null,"event","event",301435442)], null),cljs.core.subvec,(1)),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword("re-frame.std-interceptors","untrimmed-event","re-frame.std-interceptors/untrimmed-event",-840935075)], null),re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"event","event",301435442)));
}),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$std_interceptors$trimv_after(context){
return cljs.core.assoc_in.call(null,re_frame.utils.dissoc_in.call(null,context,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword("re-frame.std-interceptors","untrimmed-event","re-frame.std-interceptors/untrimmed-event",-840935075)], null)),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"coeffects","coeffects",497912985),new cljs.core.Keyword(null,"event","event",301435442)], null),re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword("re-frame.std-interceptors","untrimmed-event","re-frame.std-interceptors/untrimmed-event",-840935075)));
}));
/**
* Returns an interceptor which wraps the kind of event handler given to `reg-event-db`.
*
* These handlers take two arguments; `db` and `event`, and they return `db`.
*
* (fn [db event]
* ....)
*
* So, the interceptor wraps the given handler:
* 1. extracts two `:coeffects` keys: db and event
* 2. calls handler-fn
* 3. stores the db result back into context's `:effects`
*/
re_frame.std_interceptors.db_handler__GT_interceptor = (function re_frame$std_interceptors$db_handler__GT_interceptor(handler_fn){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"db-handler","db-handler",579530098),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$std_interceptors$db_handler__GT_interceptor_$_db_handler_before(context){
var map__33050 = new cljs.core.Keyword(null,"coeffects","coeffects",497912985).cljs$core$IFn$_invoke$arity$1(context);
var map__33050__$1 = ((((!((map__33050 == null)))?((((map__33050.cljs$lang$protocol_mask$partition0$ & (64))) || (map__33050.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__33050):map__33050);
var db = cljs.core.get.call(null,map__33050__$1,new cljs.core.Keyword(null,"db","db",993250759));
var event = cljs.core.get.call(null,map__33050__$1,new cljs.core.Keyword(null,"event","event",301435442));
return re_frame.interceptor.assoc_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759),handler_fn.call(null,db,event));
}));
});
/**
* Returns an interceptor which wraps the kind of event handler given to `reg-event-fx`.
*
* These handlers take two arguments; `coeffects` and `event`, and they return `effects`.
*
* (fn [coeffects event]
* {:db ...
* :dispatch ...})
*
* Wrap handler in an interceptor so it can be added to (the RHS) of a chain:
* 1. extracts `:coeffects`
* 2. call handler-fn giving coeffects
* 3. stores the result back into the `:effects`
*/
re_frame.std_interceptors.fx_handler__GT_interceptor = (function re_frame$std_interceptors$fx_handler__GT_interceptor(handler_fn){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"fx-handler","fx-handler",-549783097),new cljs.core.Keyword(null,"before","before",-1633692388),(function re_frame$std_interceptors$fx_handler__GT_interceptor_$_fx_handler_before(context){
var map__33058 = new cljs.core.Keyword(null,"coeffects","coeffects",497912985).cljs$core$IFn$_invoke$arity$1(context);
var map__33058__$1 = ((((!((map__33058 == null)))?((((map__33058.cljs$lang$protocol_mask$partition0$ & (64))) || (map__33058.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__33058):map__33058);
var coeffects = map__33058__$1;
var event = cljs.core.get.call(null,map__33058__$1,new cljs.core.Keyword(null,"event","event",301435442));
return cljs.core.assoc.call(null,context,new cljs.core.Keyword(null,"effects","effects",-282369292),handler_fn.call(null,coeffects,event));
}));
});
/**
* Returns an interceptor which wraps the kind of event handler given to `reg-event-ctx`.
* These advanced handlers take one argument: `context` and they return a modified `context`.
* Example:
* (fn [context]
* (enqueue context [more interceptors]))
*/
re_frame.std_interceptors.ctx_handler__GT_interceptor = (function re_frame$std_interceptors$ctx_handler__GT_interceptor(handler_fn){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"ctx-handler","ctx-handler",-1777672230),new cljs.core.Keyword(null,"before","before",-1633692388),handler_fn);
});
/**
* An interceptor factory which supplies a sub-path of `:db` to the handler.
* It's action is somewhat analogous to `update-in`. It grafts the return
* value from the handler back into db.
*
* Usage:
* (path :some :path)
* (path [:some :path])
* (path [:some :path] :to :here)
* (path [:some :path] [:to] :here)
*
* Notes:
* 1. cater for `path` appearing more than once in an interceptor chain.
* 2. `:effects` may not contain `:db` effect. Which means no change to
* `:db` should be made.
*
*/
re_frame.std_interceptors.path = (function re_frame$std_interceptors$path(var_args){
var args__26212__auto__ = [];
var len__26205__auto___33061 = arguments.length;
var i__26206__auto___33062 = (0);
while(true){
if((i__26206__auto___33062 < len__26205__auto___33061)){
args__26212__auto__.push((arguments[i__26206__auto___33062]));
var G__33063 = (i__26206__auto___33062 + (1));
i__26206__auto___33062 = G__33063;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((0) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((0)),(0),null)):null);
return re_frame.std_interceptors.path.cljs$core$IFn$_invoke$arity$variadic(argseq__26213__auto__);
});
re_frame.std_interceptors.path.cljs$core$IFn$_invoke$arity$variadic = (function (args){
var path = cljs.core.flatten.call(null,args);
var db_store_key = new cljs.core.Keyword("re-frame-path","db-store","re-frame-path/db-store",655758490);
if(cljs.core.empty_QMARK_.call(null,path)){
re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: \"path\" interceptor given no params");
} else {
}
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"path","path",-188191168),new cljs.core.Keyword(null,"before","before",-1633692388),((function (path,db_store_key){
return (function (context){
var original_db = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
return re_frame.interceptor.assoc_coeffect.call(null,cljs.core.update.call(null,context,db_store_key,cljs.core.conj,original_db),new cljs.core.Keyword(null,"db","db",993250759),cljs.core.get_in.call(null,original_db,path));
});})(path,db_store_key))
,new cljs.core.Keyword(null,"after","after",594996914),((function (path,db_store_key){
return (function (context){
var db_store = db_store_key.call(null,context);
var original_db = cljs.core.peek.call(null,db_store);
var new_db_store = cljs.core.pop.call(null,db_store);
var context_SINGLEQUOTE_ = re_frame.interceptor.assoc_coeffect.call(null,cljs.core.assoc.call(null,context,db_store_key,new_db_store),new cljs.core.Keyword(null,"db","db",993250759),original_db);
var db = re_frame.interceptor.get_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759),new cljs.core.Keyword("re-frame.std-interceptors","not-found","re-frame.std-interceptors/not-found",-1614827865));
if(cljs.core._EQ_.call(null,db,new cljs.core.Keyword("re-frame.std-interceptors","not-found","re-frame.std-interceptors/not-found",-1614827865))){
return context_SINGLEQUOTE_;
} else {
return re_frame.interceptor.assoc_effect.call(null,context_SINGLEQUOTE_,new cljs.core.Keyword(null,"db","db",993250759),cljs.core.assoc_in.call(null,original_db,path,db));
}
});})(path,db_store_key))
);
});
re_frame.std_interceptors.path.cljs$lang$maxFixedArity = (0);
re_frame.std_interceptors.path.cljs$lang$applyTo = (function (seq33060){
return re_frame.std_interceptors.path.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq33060));
});
/**
* Interceptor factory which runs the given function `f` in the `after handler`
* position. `f` is called with two arguments: `db` and `v`, and is expected to
* return a modified `db`.
*
* Unlike the `after` inteceptor which is only about side effects, `enrich`
* expects `f` to process and alter the given `db` coeffect in some useful way,
* contributing to the derived data, flowing vibe.
*
* Example Use:
* ------------
*
* Imagine that todomvc needed to do duplicate detection - if any two todos had
* the same text, then highlight their background, and report them in a warning
* down the bottom of the panel.
*
* Almost any user action (edit text, add new todo, remove a todo) requires a
* complete reassesment of duplication errors and warnings. Eg: that edit
* just made might have introduced a new duplicate, or removed one. Same with
* any todo removal. So we need to re-calculate warnings after any CRUD events
* associated with the todos list.
*
* Unless we are careful, we might end up coding subtly different checks
* for each kind of CRUD operation. The duplicates check made after
* 'delete todo' event might be subtly different to that done after an
* eddting operation. Nice and efficient, but fiddly. A bug generator
* approach.
*
* So, instead, we create an `f` which recalcualtes warnings from scratch
* every time there is ANY change. It will inspect all the todos, and
* reset ALL FLAGS every time (overwriting what was there previously)
* and fully recalculate the list of duplicates (displayed at the bottom?).
*
* By applying `f` in an `:enrich` interceptor, after every CRUD event,
* we keep the handlers simple and yet we ensure this important step
* (of getting warnings right) is not missed on any change.
*
* We can test `f` easily - it is a pure fucntions - independently of
* any CRUD operation.
*
* This brings huge simplicity at the expense of some re-computation
* each time. This may be a very satisfactory tradeoff in many cases.
*/
re_frame.std_interceptors.enrich = (function re_frame$std_interceptors$enrich(f){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"enrich","enrich",-2108921925),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$std_interceptors$enrich_$_enrich_after(context){
var event = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"event","event",301435442));
var db = (function (){var or__25130__auto__ = re_frame.interceptor.get_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
if(cljs.core.truth_(or__25130__auto__)){
return or__25130__auto__;
} else {
return re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
}
})();
return re_frame.interceptor.assoc_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759),f.call(null,db,event));
}));
});
/**
* Interceptor factory which runs a given function `f` in the "after"
* position, presumably for side effects.
*
* `f` is called with two arguments: the `effects` value of `:db`
* (or the `coeffect` value of db if no db effect is returned) and the event.
* Its return value is ignored so `f` can only side-effect.
*
* Example use:
* - `f` runs schema validation (reporting any errors found)
* - `f` writes some aspect of db to localstorage.
*/
re_frame.std_interceptors.after = (function re_frame$std_interceptors$after(f){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"after","after",594996914),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$std_interceptors$after_$_after_after(context){
var db = (function (){var or__25130__auto__ = re_frame.interceptor.get_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
if(cljs.core.truth_(or__25130__auto__)){
return or__25130__auto__;
} else {
return re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
}
})();
var event = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"event","event",301435442));
f.call(null,db,event);
return context;
}));
});
/**
* Interceptor factory which acts a bit like `reaction` (but it flows into `db`, rather than out)
* It observes N paths in `db` and if any of them test not indentical? to their previous value
* (as a result of a handler being run) then it runs `f` to compute a new value, which is
* then assoced into the given `out-path` within `db`.
*
* Usage:
*
* (defn my-f
* [a-val b-val]
* ... some computation on a and b in here)
*
* (on-changes my-f [:c] [:a] [:b])
*
* Put this Interceptor on the right handlers (ones which might change :a or :b).
* It will:
* - call `f` each time the value at path [:a] or [:b] changes
* - call `f` with the values extracted from [:a] [:b]
* - assoc the return value from `f` into the path [:c]
*
*/
re_frame.std_interceptors.on_changes = (function re_frame$std_interceptors$on_changes(var_args){
var args__26212__auto__ = [];
var len__26205__auto___33069 = arguments.length;
var i__26206__auto___33070 = (0);
while(true){
if((i__26206__auto___33070 < len__26205__auto___33069)){
args__26212__auto__.push((arguments[i__26206__auto___33070]));
var G__33071 = (i__26206__auto___33070 + (1));
i__26206__auto___33070 = G__33071;
continue;
} else {
}
break;
}
var argseq__26213__auto__ = ((((2) < args__26212__auto__.length))?(new cljs.core.IndexedSeq(args__26212__auto__.slice((2)),(0),null)):null);
return re_frame.std_interceptors.on_changes.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__26213__auto__);
});
re_frame.std_interceptors.on_changes.cljs$core$IFn$_invoke$arity$variadic = (function (f,out_path,in_paths){
return re_frame.interceptor.__GT_interceptor.call(null,new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"on-changes","on-changes",1345912602),new cljs.core.Keyword(null,"after","after",594996914),(function re_frame$std_interceptors$on_change_after(context){
var new_db = re_frame.interceptor.get_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
var old_db = re_frame.interceptor.get_coeffect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759));
var new_ins = cljs.core.map.call(null,((function (new_db,old_db){
return (function (p1__33064_SHARP_){
return cljs.core.get_in.call(null,new_db,p1__33064_SHARP_);
});})(new_db,old_db))
,in_paths);
var old_ins = cljs.core.map.call(null,((function (new_db,old_db,new_ins){
return (function (p1__33065_SHARP_){
return cljs.core.get_in.call(null,old_db,p1__33065_SHARP_);
});})(new_db,old_db,new_ins))
,in_paths);
var changed_ins_QMARK_ = cljs.core.some.call(null,cljs.core.false_QMARK_,cljs.core.map.call(null,cljs.core.identical_QMARK_,new_ins,old_ins));
if(cljs.core.truth_(changed_ins_QMARK_)){
return re_frame.interceptor.assoc_effect.call(null,context,new cljs.core.Keyword(null,"db","db",993250759),cljs.core.assoc_in.call(null,new_db,out_path,cljs.core.apply.call(null,f,new_ins)));
} else {
return context;
}
}));
});
re_frame.std_interceptors.on_changes.cljs$lang$maxFixedArity = (2);
re_frame.std_interceptors.on_changes.cljs$lang$applyTo = (function (seq33066){
var G__33067 = cljs.core.first.call(null,seq33066);
var seq33066__$1 = cljs.core.next.call(null,seq33066);
var G__33068 = cljs.core.first.call(null,seq33066__$1);
var seq33066__$2 = cljs.core.next.call(null,seq33066__$1);
return re_frame.std_interceptors.on_changes.cljs$core$IFn$_invoke$arity$variadic(G__33067,G__33068,seq33066__$2);
});
//# sourceMappingURL=std_interceptors.js.map?rel=1603199198375

1
resources/public/js/compiled/out/re_frame/std_interceptors.js.map Normal file
View file

File diff suppressed because one or more lines are too long

229
resources/public/js/compiled/out/re_frame/subs.cljc Normal file
View file

@ -0,0 +1,229 @@
(ns re-frame.subs
(:require
[re-frame.db :refer [app-db]]
[re-frame.interop :refer [add-on-dispose! debug-enabled? make-reaction ratom? deref? dispose! reagent-id]]
[re-frame.loggers :refer [console]]
[re-frame.utils :refer [first-in-vector]]
[re-frame.registrar :refer [get-handler clear-handlers register-handler]]
[re-frame.trace :as trace :include-macros true]))
(def kind :sub)
(assert (re-frame.registrar/kinds kind))
;; -- cache -------------------------------------------------------------------
;;
;; De-duplicate subscriptions. If two or more equal subscriptions
;; are concurrently active, we want only one handler running.
;; Two subscriptions are "equal" if their query vectors test "=".
(def query->reaction (atom {}))
(defn clear-subscription-cache!
"Runs on-dispose for all subscriptions we have in the subscription cache.
Used to force recreation of new subscriptions. Should only be necessary
in development.
The on-dispose functions for the subscriptions will remove themselves from the
cache.
Useful when reloading Figwheel code after a React exception, as React components
aren't cleaned up properly. This means a subscription's on-dispose function isn't
run when the components are destroyed. If a bad subscription caused your exception,
then you can't fix it without reloading your browser."
[]
(doseq [[k rxn] @query->reaction]
(dispose! rxn))
(if (not-empty @query->reaction)
(console :warn "Subscription cache should be empty after clearing it.")))
(defn clear-all-handlers!
"Unregisters all existing subscription handlers"
[]
(clear-handlers kind)
(clear-subscription-cache!))
(defn cache-and-return
"cache the reaction r"
[query-v dynv r]
(let [cache-key [query-v dynv]]
;; when this reaction is no longer being used, remove it from the cache
(add-on-dispose! r #(do (swap! query->reaction dissoc cache-key)
(trace/with-trace {:operation (first-in-vector query-v)
:op-type :sub/dispose
:tags {:query-v query-v
:reaction (reagent-id r)}}
nil)))
;; cache this reaction, so it can be used to deduplicate other, later "=" subscriptions
(swap! query->reaction assoc cache-key r)
(trace/merge-trace! {:tags {:reaction (reagent-id r)}})
r)) ;; return the actual reaction
(defn cache-lookup
([query-v]
(cache-lookup query-v []))
([query-v dyn-v]
(get @query->reaction [query-v dyn-v])))
;; -- subscribe -----------------------------------------------------
(defn subscribe
"Returns a Reagent/reaction which contains a computation"
([query-v]
(trace/with-trace {:operation (first-in-vector query-v)
:op-type :sub/create
:tags {:query-v query-v}}
(if-let [cached (cache-lookup query-v)]
(do
(trace/merge-trace! {:tags {:cached? true
:reaction (reagent-id cached)}})
cached)
(let [query-id (first-in-vector query-v)
handler-fn (get-handler kind query-id)]
(trace/merge-trace! {:tags {:cached? false}})
(if (nil? handler-fn)
(do (trace/merge-trace! {:error true})
(console :error (str "re-frame: no subscription handler registered for: \"" query-id "\". Returning a nil subscription.")))
(cache-and-return query-v [] (handler-fn app-db query-v)))))))
([v dynv]
(trace/with-trace {:operation (first-in-vector v)
:op-type :sub/create
:tags {:query-v v
:dyn-v dynv}}
(if-let [cached (cache-lookup v dynv)]
(do
(trace/merge-trace! {:tags {:cached? true
:reaction (reagent-id cached)}})
cached)
(let [query-id (first-in-vector v)
handler-fn (get-handler kind query-id)]
(trace/merge-trace! {:tags {:cached? false}})
(when debug-enabled?
(when-let [not-reactive (not-empty (remove ratom? dynv))]
(console :warn "re-frame: your subscription's dynamic parameters that don't implement IReactiveAtom:" not-reactive)))
(if (nil? handler-fn)
(do (trace/merge-trace! {:error true})
(console :error (str "re-frame: no subscription handler registered for: \"" query-id "\". Returning a nil subscription.")))
(let [dyn-vals (make-reaction (fn [] (mapv deref dynv)))
sub (make-reaction (fn [] (handler-fn app-db v @dyn-vals)))]
;; handler-fn returns a reaction which is then wrapped in the sub reaction
;; need to double deref it to get to the actual value.
;(console :log "Subscription created: " v dynv)
(cache-and-return v dynv (make-reaction (fn [] @@sub))))))))))
;; -- reg-sub -----------------------------------------------------------------
(defn- map-vals
"Returns a new version of 'm' in which 'f' has been applied to each value.
(map-vals inc {:a 4, :b 2}) => {:a 5, :b 3}"
[f m]
(into (empty m)
(map (fn [[k v]] [k (f v)]))
m))
(defn- deref-input-signals
[signals query-id]
(let [signals (cond
(sequential? signals) (map deref signals)
(map? signals) (map-vals deref signals)
(deref? signals) @signals
:else (console :error "re-frame: in the reg-sub for " query-id ", the input-signals function returns: " signals))]
(trace/merge-trace! {:tags {:input-signals (map reagent-id signals)}})
signals))
(defn reg-sub
"Associate the given `query id` with a handler function and an optional signal function.
There's 3 ways this function can be called
1. (reg-sub
:test-sub
(fn [db [_]] db))
The value in app-db is passed to the computation function as the 1st argument.
2. (reg-sub
:a-b-sub
(fn [q-vec d-vec]
[(subs/subscribe [:a-sub])
(subs/subscribe [:b-sub])])
(fn [[a b] [_]] {:a a :b b}))
Two functions provided. The 2nd is computation function, as before. The 1st
is returns what `input signals` should be provided to the computation. The
`input signals` function is called with two arguments: the query vector
and the dynamic vector. The return value can be singleton reaction or
a sequence of reactions.
3. (reg-sub
:a-b-sub
:<- [:a-sub]
:<- [:b-sub]
(fn [[a b] [_]] {:a a :b b}))```
This 3rd variation is just syntactic sugar for the 2nd. Pairs are supplied instead
of an `input signals` functions. `:<-` is supplied followed by the subscription
vector.
"
[query-id & args]
(let [computation-fn (last args)
input-args (butlast args) ;; may be empty, or one fn, or pairs of :<- / vector
err-header (str "re-frame: reg-sub for " query-id ", ")
inputs-fn (case (count input-args)
;; no `inputs` function provided - give the default
0 (fn
([_] app-db)
([_ _] app-db))
;; a single `inputs` fn
1 (let [f (first input-args)]
(when-not (fn? f)
(console :error err-header "2nd argument expected to be an inputs function, got:" f))
f)
;; one sugar pair
2 (let [[marker vec] input-args]
(when-not (= :<- marker)
(console :error err-header "expected :<-, got:" marker))
(fn inp-fn
([_] (subscribe vec))
([_ _] (subscribe vec))))
;; multiple sugar pairs
(let [pairs (partition 2 input-args)
markers (map first pairs)
vecs (map last pairs)]
(when-not (and (every? #{:<-} markers) (every? vector? vecs))
(console :error err-header "expected pairs of :<- and vectors, got:" pairs))
(fn inp-fn
([_] (map subscribe vecs))
([_ _] (map subscribe vecs)))))]
(register-handler
kind
query-id
(fn subs-handler-fn
([db query-vec]
(let [subscriptions (inputs-fn query-vec)
reaction-id (atom nil)
reaction (make-reaction
(fn [] (trace/with-trace {:operation (first-in-vector query-vec)
:op-type :sub/run
:tags {:query-v query-vec
:reaction @reaction-id}}
(computation-fn (deref-input-signals subscriptions query-id) query-vec))))]
(reset! reaction-id (reagent-id reaction))
reaction))
([db query-vec dyn-vec]
(let [subscriptions (inputs-fn query-vec dyn-vec)
reaction-id (atom nil)
reaction (make-reaction
(fn []
(trace/with-trace {:operation (first-in-vector query-vec)
:op-type :sub/run
:tags {:query-v query-vec
:dyn-v dyn-vec
:reaction @reaction-id}}
(computation-fn (deref-input-signals subscriptions query-id) query-vec dyn-vec))))]
(reset! reaction-id (reagent-id reaction))
reaction))))))

1
resources/public/js/compiled/out/re_frame/subs.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

1048
resources/public/js/compiled/out/re_frame/subs.js Normal file
View file

File diff suppressed because it is too large Load diff

1
resources/public/js/compiled/out/re_frame/subs.js.map Normal file
View file

File diff suppressed because one or more lines are too long

80
resources/public/js/compiled/out/re_frame/trace.cljc Normal file
View file

@ -0,0 +1,80 @@
(ns re-frame.trace
"Tracing for re-frame.
Alpha quality, subject to change/break at any time."
#?(:cljs (:require-macros [net.cgrand.macrovich :as macros]
[re-frame.trace :refer [finish-trace with-trace merge-trace!]]))
(:require [re-frame.interop :as interop]
#?(:clj [net.cgrand.macrovich :as macros])
[re-frame.loggers :refer [console]]))
(def id (atom 0))
(def ^:dynamic *current-trace* nil)
(defn reset-tracing! []
(reset! id 0))
#?(:cljs (goog-define trace-enabled? false)
:clj (def ^boolean trace-enabled? false))
(defn ^boolean is-trace-enabled?
"See https://groups.google.com/d/msg/clojurescript/jk43kmYiMhA/IHglVr_TPdgJ for more details"
[]
trace-enabled?)
(def trace-cbs (atom {}))
(defn register-trace-cb
"Registers a tracing callback function which will receive a collection of one or more traces.
Will replace an existing callback function if it shares the same key."
[key f]
(swap! trace-cbs assoc key f))
(defn remove-trace-cb [key]
(swap! trace-cbs dissoc key)
nil)
(defn next-id [] (swap! id inc))
(defn start-trace [{:keys [operation op-type tags child-of]}]
{:id (next-id)
:operation operation
:op-type op-type
:tags tags
:child-of (or child-of (:id *current-trace*))
:start (interop/now)})
(macros/deftime
(defmacro finish-trace [trace]
`(when (is-trace-enabled?)
(let [end# (interop/now)
duration# (- end# (:start ~trace))]
(doseq [[k# cb#] @trace-cbs]
(try (cb# [(assoc ~trace
:duration duration#
:end (interop/now))])
#?(:clj (catch Exception e#
(console :error "Error thrown from trace cb" k# "while storing" ~trace e#)))
#?(:cljs (catch :default e#
(console :error "Error thrown from trace cb" k# "while storing" ~trace e#))))))))
(defmacro with-trace
"Create a trace inside the scope of the with-trace macro
Common keys for trace-opts
:op-type - what kind of operation is this? e.g. :sub/create, :render.
:operation - identifier for the operation, for an subscription it would be the subscription keyword
tags - a map of arbitrary kv pairs"
[{:keys [operation op-type tags child-of] :as trace-opts} & body]
`(if (is-trace-enabled?)
(binding [*current-trace* (start-trace ~trace-opts)]
(try ~@body
(finally (finish-trace *current-trace*))))
(do ~@body)))
(defmacro merge-trace! [m]
;; Overwrite keys in tags, and all top level keys.
`(when (is-trace-enabled?)
(let [new-trace# (-> (update *current-trace* :tags merge (:tags ~m))
(merge (dissoc ~m :tags)))]
(set! *current-trace* new-trace#))
nil)))

1
resources/public/js/compiled/out/re_frame/trace.cljc.cache.edn Normal file
View file

File diff suppressed because one or more lines are too long

52
resources/public/js/compiled/out/re_frame/trace.js Normal file
View file

@ -0,0 +1,52 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.trace');
goog.require('cljs.core');
goog.require('re_frame.interop');
goog.require('re_frame.loggers');
re_frame.trace.id = cljs.core.atom.call(null,(0));
re_frame.trace._STAR_current_trace_STAR_ = null;
re_frame.trace.reset_tracing_BANG_ = (function re_frame$trace$reset_tracing_BANG_(){
return cljs.core.reset_BANG_.call(null,re_frame.trace.id,(0));
});
/** @define {boolean} */
goog.define("re_frame.trace.trace_enabled_QMARK_",false);
/**
* See https://groups.google.com/d/msg/clojurescript/jk43kmYiMhA/IHglVr_TPdgJ for more details
*/
re_frame.trace.is_trace_enabled_QMARK_ = (function re_frame$trace$is_trace_enabled_QMARK_(){
return re_frame.trace.trace_enabled_QMARK_;
});
re_frame.trace.trace_cbs = cljs.core.atom.call(null,cljs.core.PersistentArrayMap.EMPTY);
/**
* Registers a tracing callback function which will receive a collection of one or more traces.
* Will replace an existing callback function if it shares the same key.
*/
re_frame.trace.register_trace_cb = (function re_frame$trace$register_trace_cb(key,f){
return cljs.core.swap_BANG_.call(null,re_frame.trace.trace_cbs,cljs.core.assoc,key,f);
});
re_frame.trace.remove_trace_cb = (function re_frame$trace$remove_trace_cb(key){
cljs.core.swap_BANG_.call(null,re_frame.trace.trace_cbs,cljs.core.dissoc,key);
return null;
});
re_frame.trace.next_id = (function re_frame$trace$next_id(){
return cljs.core.swap_BANG_.call(null,re_frame.trace.id,cljs.core.inc);
});
re_frame.trace.start_trace = (function re_frame$trace$start_trace(p__32733){
var map__32736 = p__32733;
var map__32736__$1 = ((((!((map__32736 == null)))?((((map__32736.cljs$lang$protocol_mask$partition0$ & (64))) || (map__32736.cljs$core$ISeq$))?true:false):false))?cljs.core.apply.call(null,cljs.core.hash_map,map__32736):map__32736);
var operation = cljs.core.get.call(null,map__32736__$1,new cljs.core.Keyword(null,"operation","operation",-1267664310));
var op_type = cljs.core.get.call(null,map__32736__$1,new cljs.core.Keyword(null,"op-type","op-type",-1636141668));
var tags = cljs.core.get.call(null,map__32736__$1,new cljs.core.Keyword(null,"tags","tags",1771418977));
var child_of = cljs.core.get.call(null,map__32736__$1,new cljs.core.Keyword(null,"child-of","child-of",-903376662));
return new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,"id","id",-1388402092),re_frame.trace.next_id.call(null),new cljs.core.Keyword(null,"operation","operation",-1267664310),operation,new cljs.core.Keyword(null,"op-type","op-type",-1636141668),op_type,new cljs.core.Keyword(null,"tags","tags",1771418977),tags,new cljs.core.Keyword(null,"child-of","child-of",-903376662),(function (){var or__25130__auto__ = child_of;
if(cljs.core.truth_(or__25130__auto__)){
return or__25130__auto__;
} else {
return new cljs.core.Keyword(null,"id","id",-1388402092).cljs$core$IFn$_invoke$arity$1(re_frame.trace._STAR_current_trace_STAR_);
}
})(),new cljs.core.Keyword(null,"start","start",-355208981),re_frame.interop.now.call(null)], null);
});
//# sourceMappingURL=trace.js.map?rel=1603199197609

1
resources/public/js/compiled/out/re_frame/trace.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/trace.js","sources":["trace.cljc?rel=1603199197610"],"lineCount":52,"mappings":";AAAA;;;;AASA,AAAKA,oBAAG,yBAAA,zBAACC;AACT,2CAAA,3CAAeC;AAEf,qCAAA,rCAAMC;AAAN,AACE,yDAAA,lDAACC,gCAAOJ;;AAED,AAAA,AAAA;AAAA;AAAA,AAAAK,YAAA,sCAAA;AAGT;;;yCAAA,zCAAeC;AAAf,AAGEC;;AAEF,AAAKC,2BAAU,yBAAA,zBAACP;AAEhB;;;;mCAAA,nCAAMQ,8EAGHC,IAAIC;AAHP,AAIE,OAACC,+BAAMJ,yBAAUK,gBAAMH,IAAIC;;AAE7B,iCAAA,jCAAMG,0EAAiBJ;AAAvB,AACE,AAACE,+BAAMJ,yBAAUO,iBAAOL;;AAD1B;;AAIA,yBAAA,zBAAMM;AAAN,AAAiB,OAACJ,+BAAMZ,kBAAGiB;;AAE3B,6BAAA,qCAAAC,lEAAMK;AAAN,AAAA,IAAAJ,aAAAD;IAAAC,iBAAA,EAAA,EAAA,EAAA,CAAAA,cAAA,QAAA,EAAA,CAAA,CAAA,AAAAA,iDAAA,WAAA,AAAAA,6BAAA,KAAA,OAAA,QAAA,AAAAC,0BAAAC,mBAAAF,YAAAA;gBAAA,AAAAG,wBAAAH,eAAA,nDAA2BK;cAA3B,AAAAF,wBAAAH,eAAA,jDAAqCM;WAArC,AAAAH,wBAAAH,eAAA,9CAA6CO;eAA7C,AAAAJ,wBAAAH,eAAA,lDAAkDQ;AAAlD,AAAA,kDAAA,oFAAA,0EAAA,oEAAA,0DAAA,1OACc,AAACX,kGACDQ,sEACAC,6DACAC,kEACA,iBAAAE,oBAAID;AAAJ,AAAA,oBAAAC;AAAAA;;AAAa,OAAA,gFAAK1B;;KALhC,uDAMc,AAAC2B;;AAEf","names":["re-frame.trace\/id","cljs.core\/atom","re-frame.trace\/*current-trace*","re-frame.trace\/reset-tracing!","cljs.core\/reset!","goog\/define","re-frame.trace\/is-trace-enabled?","re-frame.trace\/trace-enabled?","re-frame.trace\/trace-cbs","re-frame.trace\/register-trace-cb","key","f","cljs.core\/swap!","cljs.core\/assoc","re-frame.trace\/remove-trace-cb","cljs.core\/dissoc","re-frame.trace\/next-id","cljs.core\/inc","p__32733","map__32736","cljs.core\/apply","cljs.core\/hash-map","cljs.core\/get","re-frame.trace\/start-trace","operation","op-type","tags","child-of","or__25130__auto__","re-frame.interop\/now"]}

24
resources/public/js/compiled/out/re_frame/utils.cljc Normal file
View file

@ -0,0 +1,24 @@
(ns re-frame.utils
(:require
[re-frame.loggers :refer [console]]))
(defn dissoc-in
"Dissociates an entry from a nested associative structure returning a new
nested structure. keys is a sequence of keys. Any empty maps that result
will not be present in the new structure.
The key thing is that 'm' remains identical? to istelf if the path was never present"
[m [k & ks :as keys]]
(if ks
(if-let [nextmap (get m k)]
(let [newmap (dissoc-in nextmap ks)]
(if (seq newmap)
(assoc m k newmap)
(dissoc m k)))
m)
(dissoc m k)))
(defn first-in-vector
[v]
(if (vector? v)
(first v)
(console :error "re-frame: expected a vector, but got:" v)))

1
resources/public/js/compiled/out/re_frame/utils.cljc.cache.edn Normal file
View file

@ -0,0 +1 @@
{:rename-macros {}, :renames {}, :use-macros {console re-frame.loggers}, :excludes #{}, :name re-frame.utils, :imports nil, :requires {re-frame.loggers re-frame.loggers}, :uses {console re-frame.loggers}, :defs {dissoc-in {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/utils.cljc", :line 5, :column 7, :end-line 5, :end-column 16, :arglists (quote ([m [k & ks :as keys]])), :doc "Dissociates an entry from a nested associative structure returning a new\n nested structure. keys is a sequence of keys. Any empty maps that result\n will not be present in the new structure.\n The key thing is that 'm' remains identical? to istelf if the path was never present"}, :name re-frame.utils/dissoc-in, :variadic false, :file "docs/js/compiled/out/re_frame/utils.cljc", :end-column 16, :method-params ([m p__32762]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 5, :end-line 5, :max-fixed-arity 2, :fn-var true, :arglists (quote ([m [k & ks :as keys]])), :doc "Dissociates an entry from a nested associative structure returning a new\n nested structure. keys is a sequence of keys. Any empty maps that result\n will not be present in the new structure.\n The key thing is that 'm' remains identical? to istelf if the path was never present"}, first-in-vector {:protocol-inline nil, :meta {:file "/Users/simon/workspace/swinging-needle-meter/docs/js/compiled/out/re_frame/utils.cljc", :line 20, :column 7, :end-line 20, :end-column 22, :arglists (quote ([v]))}, :name re-frame.utils/first-in-vector, :variadic false, :file "docs/js/compiled/out/re_frame/utils.cljc", :end-column 22, :method-params ([v]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 20, :end-line 20, :max-fixed-arity 1, :fn-var true, :arglists (quote ([v]))}}, :require-macros nil, :cljs.analyzer/constants {:seen #{:error}, :order [:error]}, :doc nil}

44
resources/public/js/compiled/out/re_frame/utils.js Normal file
View file

@ -0,0 +1,44 @@
// Compiled by ClojureScript 1.9.229 {}
goog.provide('re_frame.utils');
goog.require('cljs.core');
goog.require('re_frame.loggers');
/**
* Dissociates an entry from a nested associative structure returning a new
* nested structure. keys is a sequence of keys. Any empty maps that result
* will not be present in the new structure.
* The key thing is that 'm' remains identical? to istelf if the path was never present
*/
re_frame.utils.dissoc_in = (function re_frame$utils$dissoc_in(m,p__32762){
var vec__32766 = p__32762;
var seq__32767 = cljs.core.seq.call(null,vec__32766);
var first__32768 = cljs.core.first.call(null,seq__32767);
var seq__32767__$1 = cljs.core.next.call(null,seq__32767);
var k = first__32768;
var ks = seq__32767__$1;
var keys = vec__32766;
if(ks){
var temp__4655__auto__ = cljs.core.get.call(null,m,k);
if(cljs.core.truth_(temp__4655__auto__)){
var nextmap = temp__4655__auto__;
var newmap = re_frame$utils$dissoc_in.call(null,nextmap,ks);
if(cljs.core.seq.call(null,newmap)){
return cljs.core.assoc.call(null,m,k,newmap);
} else {
return cljs.core.dissoc.call(null,m,k);
}
} else {
return m;
}
} else {
return cljs.core.dissoc.call(null,m,k);
}
});
re_frame.utils.first_in_vector = (function re_frame$utils$first_in_vector(v){
if(cljs.core.vector_QMARK_.call(null,v)){
return cljs.core.first.call(null,v);
} else {
return re_frame.loggers.console.call(null,new cljs.core.Keyword(null,"error","error",-978969032),"re-frame: expected a vector, but got:",v);
}
});
//# sourceMappingURL=utils.js.map?rel=1603199197688

1
resources/public/js/compiled/out/re_frame/utils.js.map Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/re_frame\/utils.js","sources":["utils.cljc?rel=1603199197688"],"lineCount":44,"mappings":";AAAA;;;AAIA;;;;;;2BAAA,qCAAAA,hEAAMO,8DAKHC;AALH,AAAA,IAAAP,aAAAD;IAAAE,aAAA,AAAAC,wBAAAF;IAAAG,eAAA,AAAAC,0BAAAH;IAAAA,iBAAA,AAAAI,yBAAAJ;QAAAE,JAKMK;SALNP,LAKUQ;WALVT,PAKiBU;AALjB,AAME,GAAID;AACF,IAAAE,qBAAiB,AAACE,wBAAIN,EAAEC;AAAxB,AAAA,oBAAAG;AAAA,cAAAA,VAASC;AAAT,AACE,IAAME,SAAO,AAACC,mCAAUH,QAAQH;AAAhC,AACE,GAAI,AAACP,wBAAIY;AACP,OAACE,0BAAMT,EAAEC,EAAEM;;AACX,OAACG,2BAAOV,EAAEC;;;AACdD;;;AACF,OAACU,2BAAOV,EAAEC;;;AAEd,iCAAA,jCAAMU,0EACHC;AADH,AAEE,GAAI,AAACC,kCAAQD;AACX,OAACf,0BAAMe;;AACP,0CAAA,uDAAA,1FAACE,kIAAuDF","names":["p__32762","vec__32766","seq__32767","cljs.core\/seq","first__32768","cljs.core\/first","cljs.core\/next","re-frame.utils\/dissoc-in","m","k","ks","keys","temp__4655__auto__","nextmap","cljs.core\/get","newmap","dissoc-in","cljs.core\/assoc","cljs.core\/dissoc","re-frame.utils\/first-in-vector","v","cljs.core\/vector?","re-frame.loggers\/console"]}