fix bugs in page
This commit is contained in:
didier amyot committed
1 parent
6ed638a1cc
commit
e654fdfea6
387 files changed
+13618
-88879
No files matched your search
@@ -0,0 +1,349 @@
|
||||
(ns reagent.core
|
||||
(:require-macros [reagent.core])
|
||||
(:refer-clojure :exclude [partial atom flush])
|
||||
(:require [reagent.impl.template :as tmpl]
|
||||
[reagent.impl.component :as comp]
|
||||
[reagent.impl.util :as util]
|
||||
[reagent.impl.batching :as batch]
|
||||
[reagent.ratom :as ratom]
|
||||
[reagent.debug :as deb :refer-macros [dbg prn
|
||||
assert-some assert-component
|
||||
assert-js-object assert-new-state
|
||||
assert-callable]]
|
||||
[reagent.interop :refer-macros [$ $!]]
|
||||
[reagent.dom :as dom]))
|
||||
|
||||
(def is-client util/is-client)
|
||||
|
||||
(def react util/react)
|
||||
|
||||
(defn create-element
|
||||
"Create a native React element, by calling React.createElement directly.
|
||||
|
||||
That means the second argument must be a javascript object (or nil), and
|
||||
that any Reagent hiccup forms must be processed with as-element. For example
|
||||
like this:
|
||||
|
||||
(r/create-element \"div\" #js{:className \"foo\"}
|
||||
\"Hi \" (r/as-element [:strong \"world!\"])
|
||||
|
||||
which is equivalent to
|
||||
|
||||
[:div.foo \"Hi\" [:strong \"world!\"]]"
|
||||
([type]
|
||||
(create-element type nil))
|
||||
([type props]
|
||||
(assert-js-object props)
|
||||
($ react createElement type props))
|
||||
([type props child]
|
||||
(assert-js-object props)
|
||||
($ react createElement type props child))
|
||||
([type props child & children]
|
||||
(assert-js-object props)
|
||||
(apply ($ react :createElement) type props child children)))
|
||||
|
||||
(defn as-element
|
||||
"Turns a vector of Hiccup syntax into a React element. Returns form
|
||||
unchanged if it is not a vector."
|
||||
[form]
|
||||
(tmpl/as-element form))
|
||||
|
||||
(defn adapt-react-class
|
||||
"Returns an adapter for a native React class, that may be used
|
||||
just like a Reagent component function or class in Hiccup forms."
|
||||
[c]
|
||||
(assert-some c "Component")
|
||||
(tmpl/adapt-react-class c))
|
||||
|
||||
(defn reactify-component
|
||||
"Returns an adapter for a Reagent component, that may be used from
|
||||
React, for example in JSX. A single argument, props, is passed to
|
||||
the component, converted to a map."
|
||||
[c]
|
||||
(assert-some c "Component")
|
||||
(comp/reactify-component c))
|
||||
|
||||
(defn render
|
||||
"Render a Reagent component into the DOM. The first argument may be
|
||||
either a vector (using Reagent's Hiccup syntax), or a React element.
|
||||
The second argument should be a DOM node.
|
||||
|
||||
Optionally takes a callback that is called when the component is in place.
|
||||
|
||||
Returns the mounted component instance."
|
||||
([comp container]
|
||||
(dom/render comp container))
|
||||
([comp container callback]
|
||||
(dom/render comp container callback)))
|
||||
|
||||
(defn unmount-component-at-node
|
||||
"Remove a component from the given DOM node."
|
||||
[container]
|
||||
(dom/unmount-component-at-node container))
|
||||
|
||||
;; For backward compatibility
|
||||
(def as-component as-element)
|
||||
(def render-component render)
|
||||
|
||||
(defn ^:export force-update-all
|
||||
"Force re-rendering of all mounted Reagent components. This is
|
||||
probably only useful in a development environment, when you want to
|
||||
update components in response to some dynamic changes to code.
|
||||
|
||||
Note that force-update-all may not update root components. This
|
||||
happens if a component 'foo' is mounted with `(render [foo])` (since
|
||||
functions are passed by value, and not by reference, in
|
||||
ClojureScript). To get around this you'll have to introduce a layer
|
||||
of indirection, for example by using `(render [#'foo])` instead."
|
||||
[]
|
||||
(ratom/flush!)
|
||||
(dom/force-update-all)
|
||||
(batch/flush-after-render))
|
||||
|
||||
(defn create-class
|
||||
"Create a component, React style. Should be called with a map,
|
||||
looking like this:
|
||||
|
||||
{:get-initial-state (fn [this])
|
||||
:component-will-receive-props (fn [this new-argv])
|
||||
:should-component-update (fn [this old-argv new-argv])
|
||||
:component-will-mount (fn [this])
|
||||
:component-did-mount (fn [this])
|
||||
:component-will-update (fn [this new-argv])
|
||||
:component-did-update (fn [this old-argv])
|
||||
:component-will-unmount (fn [this])
|
||||
:reagent-render (fn [args....])} ;; or :render (fn [this])
|
||||
|
||||
Everything is optional, except either :reagent-render or :render."
|
||||
[spec]
|
||||
(comp/create-class spec))
|
||||
|
||||
|
||||
(defn current-component
|
||||
"Returns the current React component (a.k.a this) in a component
|
||||
function."
|
||||
[]
|
||||
comp/*current-component*)
|
||||
|
||||
(defn state-atom
|
||||
"Returns an atom containing a components state."
|
||||
[this]
|
||||
(assert-component this)
|
||||
(comp/state-atom this))
|
||||
|
||||
(defn state
|
||||
"Returns the state of a component, as set with replace-state or set-state.
|
||||
Equivalent to (deref (r/state-atom this))"
|
||||
[this]
|
||||
(assert-component this)
|
||||
(deref (state-atom this)))
|
||||
|
||||
(defn replace-state
|
||||
"Set state of a component.
|
||||
Equivalent to (reset! (state-atom this) new-state)"
|
||||
[this new-state]
|
||||
(assert-component this)
|
||||
(assert-new-state new-state)
|
||||
(reset! (state-atom this) new-state))
|
||||
|
||||
(defn set-state
|
||||
"Merge component state with new-state.
|
||||
Equivalent to (swap! (state-atom this) merge new-state)"
|
||||
[this new-state]
|
||||
(assert-component this)
|
||||
(assert-new-state new-state)
|
||||
(swap! (state-atom this) merge new-state))
|
||||
|
||||
(defn force-update
|
||||
"Force a component to re-render immediately.
|
||||
|
||||
If the second argument is true, child components will also be
|
||||
re-rendered, even is their arguments have not changed."
|
||||
([this]
|
||||
(force-update this false))
|
||||
([this deep]
|
||||
(ratom/flush!)
|
||||
(util/force-update this deep)
|
||||
(batch/flush-after-render)))
|
||||
|
||||
(defn props
|
||||
"Returns the props passed to a component."
|
||||
[this]
|
||||
(assert-component this)
|
||||
(comp/get-props this))
|
||||
|
||||
(defn children
|
||||
"Returns the children passed to a component."
|
||||
[this]
|
||||
(assert-component this)
|
||||
(comp/get-children this))
|
||||
|
||||
(defn argv
|
||||
"Returns the entire Hiccup form passed to the component."
|
||||
[this]
|
||||
(assert-component this)
|
||||
(comp/get-argv this))
|
||||
|
||||
(defn dom-node
|
||||
"Returns the root DOM node of a mounted component."
|
||||
[this]
|
||||
(dom/dom-node this))
|
||||
|
||||
(defn merge-props
|
||||
"Utility function that merges two maps, handling :class and :style
|
||||
specially, like React's transferPropsTo."
|
||||
[defaults props]
|
||||
(util/merge-props defaults props))
|
||||
|
||||
(defn flush
|
||||
"Render dirty components immediately to the DOM.
|
||||
|
||||
Note that this may not work in event handlers, since React.js does
|
||||
batching of updates there."
|
||||
[]
|
||||
(batch/flush))
|
||||
|
||||
|
||||
|
||||
;; Ratom
|
||||
|
||||
(defn atom
|
||||
"Like clojure.core/atom, except that it keeps track of derefs.
|
||||
Reagent components that derefs one of these are automatically
|
||||
re-rendered."
|
||||
([x] (ratom/atom x))
|
||||
([x & rest] (apply ratom/atom x rest)))
|
||||
|
||||
(defn track
|
||||
"Takes a function and optional arguments, and returns a derefable
|
||||
containing the output of that function. If the function derefs
|
||||
Reagent atoms (or track, etc), the value will be updated whenever
|
||||
the atom changes.
|
||||
|
||||
In other words, @(track foo bar) will produce the same result
|
||||
as (foo bar), but foo will only be called again when the atoms it
|
||||
depends on changes, and will only trigger updates of components when
|
||||
its result changes.
|
||||
|
||||
track is lazy, i.e the function is only evaluated on deref."
|
||||
[f & args]
|
||||
{:pre [(ifn? f)]}
|
||||
(ratom/make-track f args))
|
||||
|
||||
(defn track!
|
||||
"An eager version of track. The function passed is called
|
||||
immediately, and continues to be called when needed, until stopped
|
||||
with dispose!."
|
||||
[f & args]
|
||||
{:pre [(ifn? f)]}
|
||||
(ratom/make-track! f args))
|
||||
|
||||
(defn dispose!
|
||||
"Stop the result of track! from updating."
|
||||
[x]
|
||||
(ratom/dispose! x))
|
||||
|
||||
(defn wrap
|
||||
"Provide a combination of value and callback, that looks like an atom.
|
||||
|
||||
The first argument can be any value, that will be returned when the
|
||||
result is deref'ed.
|
||||
|
||||
The second argument should be a function, that is called with the
|
||||
optional extra arguments provided to wrap, and the new value of the
|
||||
resulting 'atom'.
|
||||
|
||||
Use for example like this:
|
||||
|
||||
(wrap (:foo @state)
|
||||
swap! state assoc :foo)
|
||||
|
||||
Probably useful only for passing to child components."
|
||||
[value reset-fn & args]
|
||||
(assert-callable reset-fn)
|
||||
(ratom/make-wrapper value reset-fn args))
|
||||
|
||||
|
||||
;; RCursor
|
||||
|
||||
(defn cursor
|
||||
"Provide a cursor into a Reagent atom.
|
||||
|
||||
Behaves like a Reagent atom but focuses updates and derefs to
|
||||
the specified path within the wrapped Reagent atom. e.g.,
|
||||
(let [c (cursor ra [:nested :content])]
|
||||
... @c ;; equivalent to (get-in @ra [:nested :content])
|
||||
... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
|
||||
... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
|
||||
)
|
||||
|
||||
The first parameter can also be a function, that should look
|
||||
something like this:
|
||||
|
||||
(defn set-get
|
||||
([k] (get-in @state k))
|
||||
([k v] (swap! state assoc-in k v)))
|
||||
|
||||
The function will be called with one argument – the path passed to
|
||||
cursor – when the cursor is deref'ed, and two arguments (path and
|
||||
new value) when the cursor is modified.
|
||||
|
||||
Given that set-get function, (and that state is a Reagent atom, or
|
||||
another cursor) these cursors are equivalent:
|
||||
(cursor state [:foo]) and (cursor set-get [:foo]).
|
||||
|
||||
Note that a cursor is lazy: its value will not change until it is
|
||||
used. This may be noticed with add-watch."
|
||||
([src path]
|
||||
(ratom/cursor src path)))
|
||||
|
||||
|
||||
;; Utilities
|
||||
|
||||
(defn rswap!
|
||||
"Swaps the value of a to be (apply f current-value-of-atom args).
|
||||
|
||||
rswap! works like swap!, except that recursive calls to rswap! on
|
||||
the same atom are allowed – and it always returns nil."
|
||||
[a f & args]
|
||||
{:pre [(satisfies? IAtom a)
|
||||
(ifn? f)]}
|
||||
(if a.rswapping
|
||||
(-> (or a.rswapfs (set! a.rswapfs (array)))
|
||||
(.push #(apply f % args)))
|
||||
(do (set! a.rswapping true)
|
||||
(try (swap! a (fn [state]
|
||||
(loop [s (apply f state args)]
|
||||
(if-some [sf (some-> a.rswapfs .shift)]
|
||||
(recur (sf s))
|
||||
s))))
|
||||
(finally
|
||||
(set! a.rswapping false)))))
|
||||
nil)
|
||||
|
||||
(defn next-tick
|
||||
"Run f using requestAnimationFrame or equivalent.
|
||||
|
||||
f will be called just before components are rendered."
|
||||
[f]
|
||||
(batch/do-before-flush f))
|
||||
|
||||
(defn after-render
|
||||
"Run f using requestAnimationFrame or equivalent.
|
||||
|
||||
f will be called just after any queued renders in the next animation
|
||||
frame (and even if no renders actually occur)."
|
||||
[f]
|
||||
(batch/do-after-render f))
|
||||
|
||||
(defn partial
|
||||
"Works just like clojure.core/partial, but the result can be compared with ="
|
||||
[f & args]
|
||||
(util/make-partial-fn f args))
|
||||
|
||||
(defn component-path
|
||||
;; Try to return the path of component c as a string.
|
||||
;; Maybe useful for debugging and error reporting, but may break
|
||||
;; with future versions of React (and return nil).
|
||||
[c]
|
||||
(comp/component-path c))
|
||||
@@ -0,0 +1,756 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.core');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('reagent.impl.template');
|
||||
goog.require('reagent.impl.component');
|
||||
goog.require('reagent.impl.util');
|
||||
goog.require('reagent.impl.batching');
|
||||
goog.require('reagent.ratom');
|
||||
goog.require('reagent.debug');
|
||||
goog.require('reagent.interop');
|
||||
goog.require('reagent.dom');
|
||||
reagent.core.is_client = reagent.impl.util.is_client;
|
||||
reagent.core.react = reagent.impl.util.react;
|
||||
/**
|
||||
* Create a native React element, by calling React.createElement directly.
|
||||
*
|
||||
* That means the second argument must be a javascript object (or nil), and
|
||||
* that any Reagent hiccup forms must be processed with as-element. For example
|
||||
* like this:
|
||||
*
|
||||
* (r/create-element "div" #js{:className "foo"}
|
||||
* "Hi " (r/as-element [:strong "world!"])
|
||||
*
|
||||
* which is equivalent to
|
||||
*
|
||||
* [:div.foo "Hi" [:strong "world!"]]
|
||||
*/
|
||||
reagent.core.create_element = (function reagent$core$create_element(var_args){
|
||||
var G__14932 = arguments.length;
|
||||
switch (G__14932) {
|
||||
case 1:
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
|
||||
|
||||
break;
|
||||
case 2:
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
|
||||
|
||||
break;
|
||||
case 3:
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
|
||||
|
||||
break;
|
||||
default:
|
||||
var args_arr__10084__auto__ = [];
|
||||
var len__10061__auto___14934 = arguments.length;
|
||||
var i__10062__auto___14935 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14935 < len__10061__auto___14934)){
|
||||
args_arr__10084__auto__.push((arguments[i__10062__auto___14935]));
|
||||
|
||||
var G__14936 = (i__10062__auto___14935 + (1));
|
||||
i__10062__auto___14935 = G__14936;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10085__auto__ = (new cljs.core.IndexedSeq(args_arr__10084__auto__.slice((3)),(0),null));
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__10085__auto__);
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$core$IFn$_invoke$arity$1 = (function (type){
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$2(type,null);
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$core$IFn$_invoke$arity$2 = (function (type,props){
|
||||
if(!(cljs.core.map_QMARK_(props))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a JS object, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([props], 0)))].join('')),"\n","(clojure.core/not (clojure.core/map? props))"].join('')));
|
||||
}
|
||||
|
||||
return (reagent.core.react["createElement"])(type,props);
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$core$IFn$_invoke$arity$3 = (function (type,props,child){
|
||||
if(!(cljs.core.map_QMARK_(props))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a JS object, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([props], 0)))].join('')),"\n","(clojure.core/not (clojure.core/map? props))"].join('')));
|
||||
}
|
||||
|
||||
return (reagent.core.react["createElement"])(type,props,child);
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$core$IFn$_invoke$arity$variadic = (function (type,props,child,children){
|
||||
if(!(cljs.core.map_QMARK_(props))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a JS object, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([props], 0)))].join('')),"\n","(clojure.core/not (clojure.core/map? props))"].join('')));
|
||||
}
|
||||
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$5((reagent.core.react["createElement"]),type,props,child,children);
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$lang$applyTo = (function (seq14928){
|
||||
var G__14929 = cljs.core.first(seq14928);
|
||||
var seq14928__$1 = cljs.core.next(seq14928);
|
||||
var G__14930 = cljs.core.first(seq14928__$1);
|
||||
var seq14928__$2 = cljs.core.next(seq14928__$1);
|
||||
var G__14931 = cljs.core.first(seq14928__$2);
|
||||
var seq14928__$3 = cljs.core.next(seq14928__$2);
|
||||
return reagent.core.create_element.cljs$core$IFn$_invoke$arity$variadic(G__14929,G__14930,G__14931,seq14928__$3);
|
||||
});
|
||||
|
||||
reagent.core.create_element.cljs$lang$maxFixedArity = (3);
|
||||
|
||||
/**
|
||||
* Turns a vector of Hiccup syntax into a React element. Returns form
|
||||
* unchanged if it is not a vector.
|
||||
*/
|
||||
reagent.core.as_element = (function reagent$core$as_element(form){
|
||||
return reagent.impl.template.as_element(form);
|
||||
});
|
||||
/**
|
||||
* Returns an adapter for a native React class, that may be used
|
||||
* just like a Reagent component function or class in Hiccup forms.
|
||||
*/
|
||||
reagent.core.adapt_react_class = (function reagent$core$adapt_react_class(c){
|
||||
if(cljs.core.truth_(c)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Component"," must not be nil"].join('')),"\n","c"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.template.adapt_react_class(c);
|
||||
});
|
||||
/**
|
||||
* Returns an adapter for a Reagent component, that may be used from
|
||||
* React, for example in JSX. A single argument, props, is passed to
|
||||
* the component, converted to a map.
|
||||
*/
|
||||
reagent.core.reactify_component = (function reagent$core$reactify_component(c){
|
||||
if(cljs.core.truth_(c)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Component"," must not be nil"].join('')),"\n","c"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.component.reactify_component(c);
|
||||
});
|
||||
/**
|
||||
* Render a Reagent component into the DOM. The first argument may be
|
||||
* either a vector (using Reagent's Hiccup syntax), or a React element.
|
||||
* The second argument should be a DOM node.
|
||||
*
|
||||
* Optionally takes a callback that is called when the component is in place.
|
||||
*
|
||||
* Returns the mounted component instance.
|
||||
*/
|
||||
reagent.core.render = (function reagent$core$render(var_args){
|
||||
var G__14938 = arguments.length;
|
||||
switch (G__14938) {
|
||||
case 2:
|
||||
return reagent.core.render.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
|
||||
|
||||
break;
|
||||
case 3:
|
||||
return reagent.core.render.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
|
||||
|
||||
break;
|
||||
default:
|
||||
throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
reagent.core.render.cljs$core$IFn$_invoke$arity$2 = (function (comp,container){
|
||||
return reagent.dom.render.cljs$core$IFn$_invoke$arity$2(comp,container);
|
||||
});
|
||||
|
||||
reagent.core.render.cljs$core$IFn$_invoke$arity$3 = (function (comp,container,callback){
|
||||
return reagent.dom.render.cljs$core$IFn$_invoke$arity$3(comp,container,callback);
|
||||
});
|
||||
|
||||
reagent.core.render.cljs$lang$maxFixedArity = 3;
|
||||
|
||||
/**
|
||||
* Remove a component from the given DOM node.
|
||||
*/
|
||||
reagent.core.unmount_component_at_node = (function reagent$core$unmount_component_at_node(container){
|
||||
return reagent.dom.unmount_component_at_node(container);
|
||||
});
|
||||
reagent.core.as_component = reagent.core.as_element;
|
||||
reagent.core.render_component = reagent.core.render;
|
||||
/**
|
||||
* Force re-rendering of all mounted Reagent components. This is
|
||||
* probably only useful in a development environment, when you want to
|
||||
* update components in response to some dynamic changes to code.
|
||||
*
|
||||
* Note that force-update-all may not update root components. This
|
||||
* happens if a component 'foo' is mounted with `(render [foo])` (since
|
||||
* functions are passed by value, and not by reference, in
|
||||
* ClojureScript). To get around this you'll have to introduce a layer
|
||||
* of indirection, for example by using `(render [#'foo])` instead.
|
||||
*/
|
||||
reagent.core.force_update_all = (function reagent$core$force_update_all(){
|
||||
reagent.ratom.flush_BANG_();
|
||||
|
||||
reagent.dom.force_update_all();
|
||||
|
||||
return reagent.impl.batching.flush_after_render();
|
||||
});
|
||||
goog.exportSymbol('reagent.core.force_update_all', reagent.core.force_update_all);
|
||||
/**
|
||||
* Create a component, React style. Should be called with a map,
|
||||
* looking like this:
|
||||
*
|
||||
* {:get-initial-state (fn [this])
|
||||
* :component-will-receive-props (fn [this new-argv])
|
||||
* :should-component-update (fn [this old-argv new-argv])
|
||||
* :component-will-mount (fn [this])
|
||||
* :component-did-mount (fn [this])
|
||||
* :component-will-update (fn [this new-argv])
|
||||
* :component-did-update (fn [this old-argv])
|
||||
* :component-will-unmount (fn [this])
|
||||
* :reagent-render (fn [args....])} ;; or :render (fn [this])
|
||||
*
|
||||
* Everything is optional, except either :reagent-render or :render.
|
||||
*/
|
||||
reagent.core.create_class = (function reagent$core$create_class(spec){
|
||||
return reagent.impl.component.create_class(spec);
|
||||
});
|
||||
/**
|
||||
* Returns the current React component (a.k.a this) in a component
|
||||
* function.
|
||||
*/
|
||||
reagent.core.current_component = (function reagent$core$current_component(){
|
||||
return reagent.impl.component._STAR_current_component_STAR_;
|
||||
});
|
||||
/**
|
||||
* Returns an atom containing a components state.
|
||||
*/
|
||||
reagent.core.state_atom = (function reagent$core$state_atom(this$){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.component.state_atom(this$);
|
||||
});
|
||||
/**
|
||||
* Returns the state of a component, as set with replace-state or set-state.
|
||||
* Equivalent to (deref (r/state-atom this))
|
||||
*/
|
||||
reagent.core.state = (function reagent$core$state(this$){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
return cljs.core.deref(reagent.core.state_atom(this$));
|
||||
});
|
||||
/**
|
||||
* Set state of a component.
|
||||
* Equivalent to (reset! (state-atom this) new-state)
|
||||
*/
|
||||
reagent.core.replace_state = (function reagent$core$replace_state(this$,new_state){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
if(((new_state == null)) || (cljs.core.map_QMARK_(new_state))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a valid new state, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new_state], 0)))].join('')),"\n","(clojure.core/or (clojure.core/nil? new-state) (clojure.core/map? new-state))"].join('')));
|
||||
}
|
||||
|
||||
return cljs.core.reset_BANG_(reagent.core.state_atom(this$),new_state);
|
||||
});
|
||||
/**
|
||||
* Merge component state with new-state.
|
||||
* Equivalent to (swap! (state-atom this) merge new-state)
|
||||
*/
|
||||
reagent.core.set_state = (function reagent$core$set_state(this$,new_state){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
if(((new_state == null)) || (cljs.core.map_QMARK_(new_state))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a valid new state, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new_state], 0)))].join('')),"\n","(clojure.core/or (clojure.core/nil? new-state) (clojure.core/map? new-state))"].join('')));
|
||||
}
|
||||
|
||||
return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(reagent.core.state_atom(this$),cljs.core.merge,new_state);
|
||||
});
|
||||
/**
|
||||
* Force a component to re-render immediately.
|
||||
*
|
||||
* If the second argument is true, child components will also be
|
||||
* re-rendered, even is their arguments have not changed.
|
||||
*/
|
||||
reagent.core.force_update = (function reagent$core$force_update(var_args){
|
||||
var G__14941 = arguments.length;
|
||||
switch (G__14941) {
|
||||
case 1:
|
||||
return reagent.core.force_update.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
|
||||
|
||||
break;
|
||||
case 2:
|
||||
return reagent.core.force_update.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
|
||||
|
||||
break;
|
||||
default:
|
||||
throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
reagent.core.force_update.cljs$core$IFn$_invoke$arity$1 = (function (this$){
|
||||
return reagent.core.force_update.cljs$core$IFn$_invoke$arity$2(this$,false);
|
||||
});
|
||||
|
||||
reagent.core.force_update.cljs$core$IFn$_invoke$arity$2 = (function (this$,deep){
|
||||
reagent.ratom.flush_BANG_();
|
||||
|
||||
reagent.impl.util.force_update(this$,deep);
|
||||
|
||||
return reagent.impl.batching.flush_after_render();
|
||||
});
|
||||
|
||||
reagent.core.force_update.cljs$lang$maxFixedArity = 2;
|
||||
|
||||
/**
|
||||
* Returns the props passed to a component.
|
||||
*/
|
||||
reagent.core.props = (function reagent$core$props(this$){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.component.get_props(this$);
|
||||
});
|
||||
/**
|
||||
* Returns the children passed to a component.
|
||||
*/
|
||||
reagent.core.children = (function reagent$core$children(this$){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.component.get_children(this$);
|
||||
});
|
||||
/**
|
||||
* Returns the entire Hiccup form passed to the component.
|
||||
*/
|
||||
reagent.core.argv = (function reagent$core$argv(this$){
|
||||
if(reagent.impl.component.reagent_component_QMARK_(this$)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected a reagent component, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0)))].join('')),"\n","(comp/reagent-component? this)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.component.get_argv(this$);
|
||||
});
|
||||
/**
|
||||
* Returns the root DOM node of a mounted component.
|
||||
*/
|
||||
reagent.core.dom_node = (function reagent$core$dom_node(this$){
|
||||
return reagent.dom.dom_node(this$);
|
||||
});
|
||||
/**
|
||||
* Utility function that merges two maps, handling :class and :style
|
||||
* specially, like React's transferPropsTo.
|
||||
*/
|
||||
reagent.core.merge_props = (function reagent$core$merge_props(defaults,props){
|
||||
return reagent.impl.util.merge_props(defaults,props);
|
||||
});
|
||||
/**
|
||||
* Render dirty components immediately to the DOM.
|
||||
*
|
||||
* Note that this may not work in event handlers, since React.js does
|
||||
* batching of updates there.
|
||||
*/
|
||||
reagent.core.flush = (function reagent$core$flush(){
|
||||
return reagent.impl.batching.flush();
|
||||
});
|
||||
/**
|
||||
* Like clojure.core/atom, except that it keeps track of derefs.
|
||||
* Reagent components that derefs one of these are automatically
|
||||
* re-rendered.
|
||||
*/
|
||||
reagent.core.atom = (function reagent$core$atom(var_args){
|
||||
var G__14946 = arguments.length;
|
||||
switch (G__14946) {
|
||||
case 1:
|
||||
return reagent.core.atom.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
|
||||
|
||||
break;
|
||||
default:
|
||||
var args_arr__10084__auto__ = [];
|
||||
var len__10061__auto___14948 = arguments.length;
|
||||
var i__10062__auto___14949 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14949 < len__10061__auto___14948)){
|
||||
args_arr__10084__auto__.push((arguments[i__10062__auto___14949]));
|
||||
|
||||
var G__14950 = (i__10062__auto___14949 + (1));
|
||||
i__10062__auto___14949 = G__14950;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10085__auto__ = (new cljs.core.IndexedSeq(args_arr__10084__auto__.slice((1)),(0),null));
|
||||
return reagent.core.atom.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__10085__auto__);
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
reagent.core.atom.cljs$core$IFn$_invoke$arity$1 = (function (x){
|
||||
return reagent.ratom.atom.cljs$core$IFn$_invoke$arity$1(x);
|
||||
});
|
||||
|
||||
reagent.core.atom.cljs$core$IFn$_invoke$arity$variadic = (function (x,rest){
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(reagent.ratom.atom,x,rest);
|
||||
});
|
||||
|
||||
reagent.core.atom.cljs$lang$applyTo = (function (seq14944){
|
||||
var G__14945 = cljs.core.first(seq14944);
|
||||
var seq14944__$1 = cljs.core.next(seq14944);
|
||||
return reagent.core.atom.cljs$core$IFn$_invoke$arity$variadic(G__14945,seq14944__$1);
|
||||
});
|
||||
|
||||
reagent.core.atom.cljs$lang$maxFixedArity = (1);
|
||||
|
||||
/**
|
||||
* Takes a function and optional arguments, and returns a derefable
|
||||
* containing the output of that function. If the function derefs
|
||||
* Reagent atoms (or track, etc), the value will be updated whenever
|
||||
* the atom changes.
|
||||
*
|
||||
* In other words, @(track foo bar) will produce the same result
|
||||
* as (foo bar), but foo will only be called again when the atoms it
|
||||
* depends on changes, and will only trigger updates of components when
|
||||
* its result changes.
|
||||
*
|
||||
* track is lazy, i.e the function is only evaluated on deref.
|
||||
*/
|
||||
reagent.core.track = (function reagent$core$track(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14953 = arguments.length;
|
||||
var i__10062__auto___14954 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14954 < len__10061__auto___14953)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14954]));
|
||||
|
||||
var G__14955 = (i__10062__auto___14954 + (1));
|
||||
i__10062__auto___14954 = G__14955;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((1) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((1)),(0),null)):null);
|
||||
return reagent.core.track.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.core.track.cljs$core$IFn$_invoke$arity$variadic = (function (f,args){
|
||||
if(cljs.core.ifn_QMARK_(f)){
|
||||
} else {
|
||||
throw (new Error("Assert failed: (ifn? f)"));
|
||||
}
|
||||
|
||||
return reagent.ratom.make_track(f,args);
|
||||
});
|
||||
|
||||
reagent.core.track.cljs$lang$maxFixedArity = (1);
|
||||
|
||||
reagent.core.track.cljs$lang$applyTo = (function (seq14951){
|
||||
var G__14952 = cljs.core.first(seq14951);
|
||||
var seq14951__$1 = cljs.core.next(seq14951);
|
||||
return reagent.core.track.cljs$core$IFn$_invoke$arity$variadic(G__14952,seq14951__$1);
|
||||
});
|
||||
|
||||
/**
|
||||
* An eager version of track. The function passed is called
|
||||
* immediately, and continues to be called when needed, until stopped
|
||||
* with dispose!.
|
||||
*/
|
||||
reagent.core.track_BANG_ = (function reagent$core$track_BANG_(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14958 = arguments.length;
|
||||
var i__10062__auto___14959 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14959 < len__10061__auto___14958)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14959]));
|
||||
|
||||
var G__14960 = (i__10062__auto___14959 + (1));
|
||||
i__10062__auto___14959 = G__14960;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((1) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((1)),(0),null)):null);
|
||||
return reagent.core.track_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.core.track_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (f,args){
|
||||
if(cljs.core.ifn_QMARK_(f)){
|
||||
} else {
|
||||
throw (new Error("Assert failed: (ifn? f)"));
|
||||
}
|
||||
|
||||
return reagent.ratom.make_track_BANG_(f,args);
|
||||
});
|
||||
|
||||
reagent.core.track_BANG_.cljs$lang$maxFixedArity = (1);
|
||||
|
||||
reagent.core.track_BANG_.cljs$lang$applyTo = (function (seq14956){
|
||||
var G__14957 = cljs.core.first(seq14956);
|
||||
var seq14956__$1 = cljs.core.next(seq14956);
|
||||
return reagent.core.track_BANG_.cljs$core$IFn$_invoke$arity$variadic(G__14957,seq14956__$1);
|
||||
});
|
||||
|
||||
/**
|
||||
* Stop the result of track! from updating.
|
||||
*/
|
||||
reagent.core.dispose_BANG_ = (function reagent$core$dispose_BANG_(x){
|
||||
return reagent.ratom.dispose_BANG_(x);
|
||||
});
|
||||
/**
|
||||
* Provide a combination of value and callback, that looks like an atom.
|
||||
*
|
||||
* The first argument can be any value, that will be returned when the
|
||||
* result is deref'ed.
|
||||
*
|
||||
* The second argument should be a function, that is called with the
|
||||
* optional extra arguments provided to wrap, and the new value of the
|
||||
* resulting 'atom'.
|
||||
*
|
||||
* Use for example like this:
|
||||
*
|
||||
* (wrap (:foo @state)
|
||||
* swap! state assoc :foo)
|
||||
*
|
||||
* Probably useful only for passing to child components.
|
||||
*/
|
||||
reagent.core.wrap = (function reagent$core$wrap(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14964 = arguments.length;
|
||||
var i__10062__auto___14965 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14965 < len__10061__auto___14964)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14965]));
|
||||
|
||||
var G__14966 = (i__10062__auto___14965 + (1));
|
||||
i__10062__auto___14965 = G__14966;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((2) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((2)),(0),null)):null);
|
||||
return reagent.core.wrap.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.core.wrap.cljs$core$IFn$_invoke$arity$variadic = (function (value,reset_fn,args){
|
||||
if(cljs.core.ifn_QMARK_(reset_fn)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected something callable, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([reset_fn], 0)))].join('')),"\n","(clojure.core/ifn? reset-fn)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.ratom.make_wrapper(value,reset_fn,args);
|
||||
});
|
||||
|
||||
reagent.core.wrap.cljs$lang$maxFixedArity = (2);
|
||||
|
||||
reagent.core.wrap.cljs$lang$applyTo = (function (seq14961){
|
||||
var G__14962 = cljs.core.first(seq14961);
|
||||
var seq14961__$1 = cljs.core.next(seq14961);
|
||||
var G__14963 = cljs.core.first(seq14961__$1);
|
||||
var seq14961__$2 = cljs.core.next(seq14961__$1);
|
||||
return reagent.core.wrap.cljs$core$IFn$_invoke$arity$variadic(G__14962,G__14963,seq14961__$2);
|
||||
});
|
||||
|
||||
/**
|
||||
* Provide a cursor into a Reagent atom.
|
||||
*
|
||||
* Behaves like a Reagent atom but focuses updates and derefs to
|
||||
* the specified path within the wrapped Reagent atom. e.g.,
|
||||
* (let [c (cursor ra [:nested :content])]
|
||||
* ... @c ;; equivalent to (get-in @ra [:nested :content])
|
||||
* ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
|
||||
* ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
|
||||
* )
|
||||
*
|
||||
* The first parameter can also be a function, that should look
|
||||
* something like this:
|
||||
*
|
||||
* (defn set-get
|
||||
* ([k] (get-in @state k))
|
||||
* ([k v] (swap! state assoc-in k v)))
|
||||
*
|
||||
* The function will be called with one argument – the path passed to
|
||||
* cursor – when the cursor is deref'ed, and two arguments (path and
|
||||
* new value) when the cursor is modified.
|
||||
*
|
||||
* Given that set-get function, (and that state is a Reagent atom, or
|
||||
* another cursor) these cursors are equivalent:
|
||||
* (cursor state [:foo]) and (cursor set-get [:foo]).
|
||||
*
|
||||
* Note that a cursor is lazy: its value will not change until it is
|
||||
* used. This may be noticed with add-watch.
|
||||
*/
|
||||
reagent.core.cursor = (function reagent$core$cursor(src,path){
|
||||
return reagent.ratom.cursor(src,path);
|
||||
});
|
||||
/**
|
||||
* Swaps the value of a to be (apply f current-value-of-atom args).
|
||||
*
|
||||
* rswap! works like swap!, except that recursive calls to rswap! on
|
||||
* the same atom are allowed – and it always returns nil.
|
||||
*/
|
||||
reagent.core.rswap_BANG_ = (function reagent$core$rswap_BANG_(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14973 = arguments.length;
|
||||
var i__10062__auto___14974 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14974 < len__10061__auto___14973)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14974]));
|
||||
|
||||
var G__14975 = (i__10062__auto___14974 + (1));
|
||||
i__10062__auto___14974 = G__14975;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((2) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((2)),(0),null)):null);
|
||||
return reagent.core.rswap_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.core.rswap_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (a,f,args){
|
||||
if(((!((a == null)))?((((a.cljs$lang$protocol_mask$partition1$ & (16384))) || ((cljs.core.PROTOCOL_SENTINEL === a.cljs$core$IAtom$)))?true:(((!a.cljs$lang$protocol_mask$partition1$))?cljs.core.native_satisfies_QMARK_(cljs.core.IAtom,a):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IAtom,a))){
|
||||
} else {
|
||||
throw (new Error("Assert failed: (satisfies? IAtom a)"));
|
||||
}
|
||||
|
||||
if(cljs.core.ifn_QMARK_(f)){
|
||||
} else {
|
||||
throw (new Error("Assert failed: (ifn? f)"));
|
||||
}
|
||||
|
||||
if(cljs.core.truth_(a.rswapping)){
|
||||
(function (){var or__8782__auto__ = a.rswapfs;
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return a.rswapfs = [];
|
||||
}
|
||||
})().push((function (p1__14967_SHARP_){
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,p1__14967_SHARP_,args);
|
||||
}));
|
||||
} else {
|
||||
a.rswapping = true;
|
||||
|
||||
try{cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(a,(function (state){
|
||||
var s = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,state,args);
|
||||
while(true){
|
||||
var temp__5459__auto__ = (function (){var G__14972 = a.rswapfs;
|
||||
if((G__14972 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return G__14972.shift();
|
||||
}
|
||||
})();
|
||||
if((temp__5459__auto__ == null)){
|
||||
return s;
|
||||
} else {
|
||||
var sf = temp__5459__auto__;
|
||||
var G__14976 = (sf.cljs$core$IFn$_invoke$arity$1 ? sf.cljs$core$IFn$_invoke$arity$1(s) : sf.call(null,s));
|
||||
s = G__14976;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}));
|
||||
}finally {a.rswapping = false;
|
||||
}}
|
||||
|
||||
return null;
|
||||
});
|
||||
|
||||
reagent.core.rswap_BANG_.cljs$lang$maxFixedArity = (2);
|
||||
|
||||
reagent.core.rswap_BANG_.cljs$lang$applyTo = (function (seq14968){
|
||||
var G__14969 = cljs.core.first(seq14968);
|
||||
var seq14968__$1 = cljs.core.next(seq14968);
|
||||
var G__14970 = cljs.core.first(seq14968__$1);
|
||||
var seq14968__$2 = cljs.core.next(seq14968__$1);
|
||||
return reagent.core.rswap_BANG_.cljs$core$IFn$_invoke$arity$variadic(G__14969,G__14970,seq14968__$2);
|
||||
});
|
||||
|
||||
/**
|
||||
* Run f using requestAnimationFrame or equivalent.
|
||||
*
|
||||
* f will be called just before components are rendered.
|
||||
*/
|
||||
reagent.core.next_tick = (function reagent$core$next_tick(f){
|
||||
return reagent.impl.batching.do_before_flush(f);
|
||||
});
|
||||
/**
|
||||
* Run f using requestAnimationFrame or equivalent.
|
||||
*
|
||||
* f will be called just after any queued renders in the next animation
|
||||
* frame (and even if no renders actually occur).
|
||||
*/
|
||||
reagent.core.after_render = (function reagent$core$after_render(f){
|
||||
return reagent.impl.batching.do_after_render(f);
|
||||
});
|
||||
/**
|
||||
* Works just like clojure.core/partial, but the result can be compared with =
|
||||
*/
|
||||
reagent.core.partial = (function reagent$core$partial(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14979 = arguments.length;
|
||||
var i__10062__auto___14980 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14980 < len__10061__auto___14979)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14980]));
|
||||
|
||||
var G__14981 = (i__10062__auto___14980 + (1));
|
||||
i__10062__auto___14980 = G__14981;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((1) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((1)),(0),null)):null);
|
||||
return reagent.core.partial.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.core.partial.cljs$core$IFn$_invoke$arity$variadic = (function (f,args){
|
||||
return reagent.impl.util.make_partial_fn(f,args);
|
||||
});
|
||||
|
||||
reagent.core.partial.cljs$lang$maxFixedArity = (1);
|
||||
|
||||
reagent.core.partial.cljs$lang$applyTo = (function (seq14977){
|
||||
var G__14978 = cljs.core.first(seq14977);
|
||||
var seq14977__$1 = cljs.core.next(seq14977);
|
||||
return reagent.core.partial.cljs$core$IFn$_invoke$arity$variadic(G__14978,seq14977__$1);
|
||||
});
|
||||
|
||||
reagent.core.component_path = (function reagent$core$component_path(c){
|
||||
return reagent.impl.component.component_path(c);
|
||||
});
|
||||
@@ -0,0 +1,27 @@
|
||||
(ns reagent.debug
|
||||
(:require-macros [reagent.debug]))
|
||||
|
||||
(def ^:const has-console (exists? js/console))
|
||||
|
||||
(def ^boolean tracking false)
|
||||
|
||||
(defonce warnings (atom nil))
|
||||
|
||||
(defonce track-console
|
||||
(let [o #js{}]
|
||||
(set! (.-warn o)
|
||||
(fn [& args]
|
||||
(swap! warnings update-in [:warn] conj (apply str args))))
|
||||
(set! (.-error o)
|
||||
(fn [& args]
|
||||
(swap! warnings update-in [:error] conj (apply str args))))
|
||||
o))
|
||||
|
||||
(defn track-warnings [f]
|
||||
(set! tracking true)
|
||||
(reset! warnings nil)
|
||||
(f)
|
||||
(let [warns @warnings]
|
||||
(reset! warnings nil)
|
||||
(set! tracking false)
|
||||
warns))
|
||||
@@ -0,0 +1,78 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.debug');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
reagent.debug.has_console = typeof console !== 'undefined';
|
||||
reagent.debug.tracking = false;
|
||||
if(typeof reagent.debug.warnings !== 'undefined'){
|
||||
} else {
|
||||
reagent.debug.warnings = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(null);
|
||||
}
|
||||
if(typeof reagent.debug.track_console !== 'undefined'){
|
||||
} else {
|
||||
reagent.debug.track_console = (function (){var o = ({});
|
||||
o.warn = ((function (o){
|
||||
return (function() {
|
||||
var G__14485__delegate = function (args){
|
||||
return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(reagent.debug.warnings,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$warn], null),cljs.core.conj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,args)], 0));
|
||||
};
|
||||
var G__14485 = function (var_args){
|
||||
var args = null;
|
||||
if (arguments.length > 0) {
|
||||
var G__14486__i = 0, G__14486__a = new Array(arguments.length - 0);
|
||||
while (G__14486__i < G__14486__a.length) {G__14486__a[G__14486__i] = arguments[G__14486__i + 0]; ++G__14486__i;}
|
||||
args = new cljs.core.IndexedSeq(G__14486__a,0,null);
|
||||
}
|
||||
return G__14485__delegate.call(this,args);};
|
||||
G__14485.cljs$lang$maxFixedArity = 0;
|
||||
G__14485.cljs$lang$applyTo = (function (arglist__14487){
|
||||
var args = cljs.core.seq(arglist__14487);
|
||||
return G__14485__delegate(args);
|
||||
});
|
||||
G__14485.cljs$core$IFn$_invoke$arity$variadic = G__14485__delegate;
|
||||
return G__14485;
|
||||
})()
|
||||
;})(o))
|
||||
;
|
||||
|
||||
o.error = ((function (o){
|
||||
return (function() {
|
||||
var G__14488__delegate = function (args){
|
||||
return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(reagent.debug.warnings,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$error], null),cljs.core.conj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,args)], 0));
|
||||
};
|
||||
var G__14488 = function (var_args){
|
||||
var args = null;
|
||||
if (arguments.length > 0) {
|
||||
var G__14489__i = 0, G__14489__a = new Array(arguments.length - 0);
|
||||
while (G__14489__i < G__14489__a.length) {G__14489__a[G__14489__i] = arguments[G__14489__i + 0]; ++G__14489__i;}
|
||||
args = new cljs.core.IndexedSeq(G__14489__a,0,null);
|
||||
}
|
||||
return G__14488__delegate.call(this,args);};
|
||||
G__14488.cljs$lang$maxFixedArity = 0;
|
||||
G__14488.cljs$lang$applyTo = (function (arglist__14490){
|
||||
var args = cljs.core.seq(arglist__14490);
|
||||
return G__14488__delegate(args);
|
||||
});
|
||||
G__14488.cljs$core$IFn$_invoke$arity$variadic = G__14488__delegate;
|
||||
return G__14488;
|
||||
})()
|
||||
;})(o))
|
||||
;
|
||||
|
||||
return o;
|
||||
})();
|
||||
}
|
||||
reagent.debug.track_warnings = (function reagent$debug$track_warnings(f){
|
||||
reagent.debug.tracking = true;
|
||||
|
||||
cljs.core.reset_BANG_(reagent.debug.warnings,null);
|
||||
|
||||
(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null));
|
||||
|
||||
var warns = cljs.core.deref(reagent.debug.warnings);
|
||||
cljs.core.reset_BANG_(reagent.debug.warnings,null);
|
||||
|
||||
reagent.debug.tracking = false;
|
||||
|
||||
return warns;
|
||||
});
|
||||
@@ -0,0 +1,80 @@
|
||||
(ns reagent.dom
|
||||
(:require [cljsjs.react.dom]
|
||||
[reagent.impl.util :as util]
|
||||
[reagent.impl.template :as tmpl]
|
||||
[reagent.impl.batching :as batch]
|
||||
[reagent.ratom :as ratom]
|
||||
[reagent.debug :refer-macros [dbg]]
|
||||
[reagent.interop :refer-macros [$ $!]]))
|
||||
|
||||
(defonce ^:private imported nil)
|
||||
|
||||
(defn module []
|
||||
(cond
|
||||
(some? imported) imported
|
||||
(exists? js/ReactDOM) (set! imported js/ReactDOM)
|
||||
(exists? js/require) (or (set! imported (js/require "react-dom"))
|
||||
(throw (js/Error. "require('react-dom') failed")))
|
||||
:else
|
||||
(throw (js/Error. "js/ReactDOM is missing"))))
|
||||
|
||||
|
||||
(defonce ^:private roots (atom {}))
|
||||
|
||||
(defn- unmount-comp [container]
|
||||
(swap! roots dissoc container)
|
||||
($ (module) unmountComponentAtNode container))
|
||||
|
||||
(defn- render-comp [comp container callback]
|
||||
(binding [util/*always-update* true]
|
||||
(->> ($ (module) render (comp) container
|
||||
(fn []
|
||||
(binding [util/*always-update* false]
|
||||
(swap! roots assoc container [comp container])
|
||||
(batch/flush-after-render)
|
||||
(if (some? callback)
|
||||
(callback))))))))
|
||||
|
||||
(defn- re-render-component [comp container]
|
||||
(render-comp comp container nil))
|
||||
|
||||
(defn render
|
||||
"Render a Reagent component into the DOM. The first argument may be
|
||||
either a vector (using Reagent's Hiccup syntax), or a React element. The second argument should be a DOM node.
|
||||
|
||||
Optionally takes a callback that is called when the component is in place.
|
||||
|
||||
Returns the mounted component instance."
|
||||
([comp container]
|
||||
(render comp container nil))
|
||||
([comp container callback]
|
||||
(ratom/flush!)
|
||||
(let [f (fn []
|
||||
(tmpl/as-element (if (fn? comp) (comp) comp)))]
|
||||
(render-comp f container callback))))
|
||||
|
||||
(defn unmount-component-at-node [container]
|
||||
(unmount-comp container))
|
||||
|
||||
(defn dom-node
|
||||
"Returns the root DOM node of a mounted component."
|
||||
[this]
|
||||
($ (module) findDOMNode this))
|
||||
|
||||
(set! tmpl/find-dom-node dom-node)
|
||||
|
||||
(defn force-update-all
|
||||
"Force re-rendering of all mounted Reagent components. This is
|
||||
probably only useful in a development environment, when you want to
|
||||
update components in response to some dynamic changes to code.
|
||||
|
||||
Note that force-update-all may not update root components. This
|
||||
happens if a component 'foo' is mounted with `(render [foo])` (since
|
||||
functions are passed by value, and not by reference, in
|
||||
ClojureScript). To get around this you'll have to introduce a layer
|
||||
of indirection, for example by using `(render [#'foo])` instead."
|
||||
[]
|
||||
(ratom/flush!)
|
||||
(doseq [v (vals @roots)]
|
||||
(apply re-render-component v))
|
||||
"Updated")
|
||||
@@ -0,0 +1,189 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.dom');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('reagent.impl.util');
|
||||
goog.require('reagent.impl.template');
|
||||
goog.require('reagent.impl.batching');
|
||||
goog.require('reagent.ratom');
|
||||
goog.require('reagent.debug');
|
||||
goog.require('reagent.interop');
|
||||
if(typeof reagent.dom.imported !== 'undefined'){
|
||||
} else {
|
||||
reagent.dom.imported = null;
|
||||
}
|
||||
reagent.dom.module = (function reagent$dom$module(){
|
||||
if(!((reagent.dom.imported == null))){
|
||||
return reagent.dom.imported;
|
||||
} else {
|
||||
if(typeof ReactDOM !== 'undefined'){
|
||||
return reagent.dom.imported = ReactDOM;
|
||||
} else {
|
||||
if(typeof require !== 'undefined'){
|
||||
var or__8782__auto__ = reagent.dom.imported = require("react-dom");
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
throw (new Error("require('react-dom') failed"));
|
||||
}
|
||||
} else {
|
||||
throw (new Error("js/ReactDOM is missing"));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
if(typeof reagent.dom.roots !== 'undefined'){
|
||||
} else {
|
||||
reagent.dom.roots = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);
|
||||
}
|
||||
reagent.dom.unmount_comp = (function reagent$dom$unmount_comp(container){
|
||||
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(reagent.dom.roots,cljs.core.dissoc,container);
|
||||
|
||||
return (reagent.dom.module()["unmountComponentAtNode"])(container);
|
||||
});
|
||||
reagent.dom.render_comp = (function reagent$dom$render_comp(comp,container,callback){
|
||||
var _STAR_always_update_STAR_14880 = reagent.impl.util._STAR_always_update_STAR_;
|
||||
reagent.impl.util._STAR_always_update_STAR_ = true;
|
||||
|
||||
try{return (reagent.dom.module()["render"])((comp.cljs$core$IFn$_invoke$arity$0 ? comp.cljs$core$IFn$_invoke$arity$0() : comp.call(null)),container,((function (_STAR_always_update_STAR_14880){
|
||||
return (function (){
|
||||
var _STAR_always_update_STAR_14881 = reagent.impl.util._STAR_always_update_STAR_;
|
||||
reagent.impl.util._STAR_always_update_STAR_ = false;
|
||||
|
||||
try{cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(reagent.dom.roots,cljs.core.assoc,container,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [comp,container], null));
|
||||
|
||||
reagent.impl.batching.flush_after_render();
|
||||
|
||||
if(!((callback == null))){
|
||||
return (callback.cljs$core$IFn$_invoke$arity$0 ? callback.cljs$core$IFn$_invoke$arity$0() : callback.call(null));
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}finally {reagent.impl.util._STAR_always_update_STAR_ = _STAR_always_update_STAR_14881;
|
||||
}});})(_STAR_always_update_STAR_14880))
|
||||
);
|
||||
}finally {reagent.impl.util._STAR_always_update_STAR_ = _STAR_always_update_STAR_14880;
|
||||
}});
|
||||
reagent.dom.re_render_component = (function reagent$dom$re_render_component(comp,container){
|
||||
return reagent.dom.render_comp(comp,container,null);
|
||||
});
|
||||
/**
|
||||
* Render a Reagent component into the DOM. The first argument may be
|
||||
* either a vector (using Reagent's Hiccup syntax), or a React element. The second argument should be a DOM node.
|
||||
*
|
||||
* Optionally takes a callback that is called when the component is in place.
|
||||
*
|
||||
* Returns the mounted component instance.
|
||||
*/
|
||||
reagent.dom.render = (function reagent$dom$render(var_args){
|
||||
var G__14883 = arguments.length;
|
||||
switch (G__14883) {
|
||||
case 2:
|
||||
return reagent.dom.render.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
|
||||
|
||||
break;
|
||||
case 3:
|
||||
return reagent.dom.render.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
|
||||
|
||||
break;
|
||||
default:
|
||||
throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
reagent.dom.render.cljs$core$IFn$_invoke$arity$2 = (function (comp,container){
|
||||
return reagent.dom.render.cljs$core$IFn$_invoke$arity$3(comp,container,null);
|
||||
});
|
||||
|
||||
reagent.dom.render.cljs$core$IFn$_invoke$arity$3 = (function (comp,container,callback){
|
||||
reagent.ratom.flush_BANG_();
|
||||
|
||||
var f = (function (){
|
||||
return reagent.impl.template.as_element(((cljs.core.fn_QMARK_(comp))?(comp.cljs$core$IFn$_invoke$arity$0 ? comp.cljs$core$IFn$_invoke$arity$0() : comp.call(null)):comp));
|
||||
});
|
||||
return reagent.dom.render_comp(f,container,callback);
|
||||
});
|
||||
|
||||
reagent.dom.render.cljs$lang$maxFixedArity = 3;
|
||||
|
||||
reagent.dom.unmount_component_at_node = (function reagent$dom$unmount_component_at_node(container){
|
||||
return reagent.dom.unmount_comp(container);
|
||||
});
|
||||
/**
|
||||
* Returns the root DOM node of a mounted component.
|
||||
*/
|
||||
reagent.dom.dom_node = (function reagent$dom$dom_node(this$){
|
||||
return (reagent.dom.module()["findDOMNode"])(this$);
|
||||
});
|
||||
reagent.impl.template.find_dom_node = reagent.dom.dom_node;
|
||||
/**
|
||||
* Force re-rendering of all mounted Reagent components. This is
|
||||
* probably only useful in a development environment, when you want to
|
||||
* update components in response to some dynamic changes to code.
|
||||
*
|
||||
* Note that force-update-all may not update root components. This
|
||||
* happens if a component 'foo' is mounted with `(render [foo])` (since
|
||||
* functions are passed by value, and not by reference, in
|
||||
* ClojureScript). To get around this you'll have to introduce a layer
|
||||
* of indirection, for example by using `(render [#'foo])` instead.
|
||||
*/
|
||||
reagent.dom.force_update_all = (function reagent$dom$force_update_all(){
|
||||
reagent.ratom.flush_BANG_();
|
||||
|
||||
var seq__14885_14889 = cljs.core.seq(cljs.core.vals(cljs.core.deref(reagent.dom.roots)));
|
||||
var chunk__14886_14890 = null;
|
||||
var count__14887_14891 = (0);
|
||||
var i__14888_14892 = (0);
|
||||
while(true){
|
||||
if((i__14888_14892 < count__14887_14891)){
|
||||
var v_14893 = chunk__14886_14890.cljs$core$IIndexed$_nth$arity$2(null,i__14888_14892);
|
||||
cljs.core.apply.cljs$core$IFn$_invoke$arity$2(reagent.dom.re_render_component,v_14893);
|
||||
|
||||
var G__14894 = seq__14885_14889;
|
||||
var G__14895 = chunk__14886_14890;
|
||||
var G__14896 = count__14887_14891;
|
||||
var G__14897 = (i__14888_14892 + (1));
|
||||
seq__14885_14889 = G__14894;
|
||||
chunk__14886_14890 = G__14895;
|
||||
count__14887_14891 = G__14896;
|
||||
i__14888_14892 = G__14897;
|
||||
continue;
|
||||
} else {
|
||||
var temp__5457__auto___14898 = cljs.core.seq(seq__14885_14889);
|
||||
if(temp__5457__auto___14898){
|
||||
var seq__14885_14899__$1 = temp__5457__auto___14898;
|
||||
if(cljs.core.chunked_seq_QMARK_(seq__14885_14899__$1)){
|
||||
var c__9713__auto___14900 = cljs.core.chunk_first(seq__14885_14899__$1);
|
||||
var G__14901 = cljs.core.chunk_rest(seq__14885_14899__$1);
|
||||
var G__14902 = c__9713__auto___14900;
|
||||
var G__14903 = cljs.core.count(c__9713__auto___14900);
|
||||
var G__14904 = (0);
|
||||
seq__14885_14889 = G__14901;
|
||||
chunk__14886_14890 = G__14902;
|
||||
count__14887_14891 = G__14903;
|
||||
i__14888_14892 = G__14904;
|
||||
continue;
|
||||
} else {
|
||||
var v_14905 = cljs.core.first(seq__14885_14899__$1);
|
||||
cljs.core.apply.cljs$core$IFn$_invoke$arity$2(reagent.dom.re_render_component,v_14905);
|
||||
|
||||
var G__14906 = cljs.core.next(seq__14885_14899__$1);
|
||||
var G__14907 = null;
|
||||
var G__14908 = (0);
|
||||
var G__14909 = (0);
|
||||
seq__14885_14889 = G__14906;
|
||||
chunk__14886_14890 = G__14907;
|
||||
count__14887_14891 = G__14908;
|
||||
i__14888_14892 = G__14909;
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return "Updated";
|
||||
});
|
||||
@@ -0,0 +1,113 @@
|
||||
(ns reagent.impl.batching
|
||||
(:refer-clojure :exclude [flush])
|
||||
(:require [reagent.debug :refer-macros [dbg assert-some]]
|
||||
[reagent.interop :refer-macros [$ $!]]
|
||||
[reagent.impl.util :refer [is-client]]
|
||||
[clojure.string :as string]))
|
||||
|
||||
;;; Update batching
|
||||
|
||||
(defonce mount-count 0)
|
||||
|
||||
(defn next-mount-count []
|
||||
(set! mount-count (inc mount-count)))
|
||||
|
||||
(defn fake-raf [f]
|
||||
(js/setTimeout f 16))
|
||||
|
||||
(def next-tick
|
||||
(if-not is-client
|
||||
fake-raf
|
||||
(let [w js/window]
|
||||
(or ($ w :requestAnimationFrame)
|
||||
($ w :webkitRequestAnimationFrame)
|
||||
($ w :mozRequestAnimationFrame)
|
||||
($ w :msRequestAnimationFrame)
|
||||
fake-raf))))
|
||||
|
||||
(defn compare-mount-order [c1 c2]
|
||||
(- ($ c1 :cljsMountOrder)
|
||||
($ c2 :cljsMountOrder)))
|
||||
|
||||
(defn run-queue [a]
|
||||
;; sort components by mount order, to make sure parents
|
||||
;; are rendered before children
|
||||
(.sort a compare-mount-order)
|
||||
(dotimes [i (alength a)]
|
||||
(let [c (aget a i)]
|
||||
(when (true? ($ c :cljsIsDirty))
|
||||
($ c forceUpdate)))))
|
||||
|
||||
|
||||
;; Set from ratom.cljs
|
||||
(defonce ratom-flush (fn []))
|
||||
|
||||
(deftype RenderQueue [^:mutable ^boolean scheduled?]
|
||||
Object
|
||||
(enqueue [this k f]
|
||||
(assert-some f "Enqueued function")
|
||||
(when (nil? (aget this k))
|
||||
(aset this k (array)))
|
||||
(.push (aget this k) f)
|
||||
(.schedule this))
|
||||
|
||||
(run-funs [this k]
|
||||
(when-some [fs (aget this k)]
|
||||
(aset this k nil)
|
||||
(dotimes [i (alength fs)]
|
||||
((aget fs i)))))
|
||||
|
||||
(schedule [this]
|
||||
(when-not scheduled?
|
||||
(set! scheduled? true)
|
||||
(next-tick #(.run-queues this))))
|
||||
|
||||
(queue-render [this c]
|
||||
(.enqueue this "componentQueue" c))
|
||||
|
||||
(add-before-flush [this f]
|
||||
(.enqueue this "beforeFlush" f))
|
||||
|
||||
(add-after-render [this f]
|
||||
(.enqueue this "afterRender" f))
|
||||
|
||||
(run-queues [this]
|
||||
(set! scheduled? false)
|
||||
(.flush-queues this))
|
||||
|
||||
(flush-after-render [this]
|
||||
(.run-funs this "afterRender"))
|
||||
|
||||
(flush-queues [this]
|
||||
(.run-funs this "beforeFlush")
|
||||
(ratom-flush)
|
||||
(when-some [cs (aget this "componentQueue")]
|
||||
(aset this "componentQueue" nil)
|
||||
(run-queue cs))
|
||||
(.flush-after-render this)))
|
||||
|
||||
(defonce render-queue (->RenderQueue false))
|
||||
|
||||
(defn flush []
|
||||
(.flush-queues render-queue))
|
||||
|
||||
(defn flush-after-render []
|
||||
(.flush-after-render render-queue))
|
||||
|
||||
(defn queue-render [c]
|
||||
(when-not ($ c :cljsIsDirty)
|
||||
($! c :cljsIsDirty true)
|
||||
(.queue-render render-queue c)))
|
||||
|
||||
(defn mark-rendered [c]
|
||||
($! c :cljsIsDirty false))
|
||||
|
||||
(defn do-before-flush [f]
|
||||
(.add-before-flush render-queue f))
|
||||
|
||||
(defn do-after-render [f]
|
||||
(.add-after-render render-queue f))
|
||||
|
||||
(defn schedule []
|
||||
(when (false? (.-scheduled? render-queue))
|
||||
(.schedule render-queue)))
|
||||
@@ -0,0 +1,245 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.impl.batching');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('reagent.debug');
|
||||
goog.require('reagent.interop');
|
||||
goog.require('reagent.impl.util');
|
||||
goog.require('clojure.string');
|
||||
if(typeof reagent.impl.batching.mount_count !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.batching.mount_count = (0);
|
||||
}
|
||||
reagent.impl.batching.next_mount_count = (function reagent$impl$batching$next_mount_count(){
|
||||
return reagent.impl.batching.mount_count = (reagent.impl.batching.mount_count + (1));
|
||||
});
|
||||
reagent.impl.batching.fake_raf = (function reagent$impl$batching$fake_raf(f){
|
||||
return setTimeout(f,(16));
|
||||
});
|
||||
reagent.impl.batching.next_tick = ((!(reagent.impl.util.is_client))?reagent.impl.batching.fake_raf:(function (){var w = window;
|
||||
var or__8782__auto__ = (w["requestAnimationFrame"]);
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
var or__8782__auto____$1 = (w["webkitRequestAnimationFrame"]);
|
||||
if(cljs.core.truth_(or__8782__auto____$1)){
|
||||
return or__8782__auto____$1;
|
||||
} else {
|
||||
var or__8782__auto____$2 = (w["mozRequestAnimationFrame"]);
|
||||
if(cljs.core.truth_(or__8782__auto____$2)){
|
||||
return or__8782__auto____$2;
|
||||
} else {
|
||||
var or__8782__auto____$3 = (w["msRequestAnimationFrame"]);
|
||||
if(cljs.core.truth_(or__8782__auto____$3)){
|
||||
return or__8782__auto____$3;
|
||||
} else {
|
||||
return reagent.impl.batching.fake_raf;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})());
|
||||
reagent.impl.batching.compare_mount_order = (function reagent$impl$batching$compare_mount_order(c1,c2){
|
||||
return ((c1["cljsMountOrder"]) - (c2["cljsMountOrder"]));
|
||||
});
|
||||
reagent.impl.batching.run_queue = (function reagent$impl$batching$run_queue(a){
|
||||
a.sort(reagent.impl.batching.compare_mount_order);
|
||||
|
||||
var n__9827__auto__ = a.length;
|
||||
var i = (0);
|
||||
while(true){
|
||||
if((i < n__9827__auto__)){
|
||||
var c_14538 = (a[i]);
|
||||
if((c_14538["cljsIsDirty"]) === true){
|
||||
(c_14538["forceUpdate"])();
|
||||
} else {
|
||||
}
|
||||
|
||||
var G__14539 = (i + (1));
|
||||
i = G__14539;
|
||||
continue;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
if(typeof reagent.impl.batching.ratom_flush !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.batching.ratom_flush = (function reagent$impl$batching$ratom_flush(){
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @implements {reagent.impl.batching.Object}
|
||||
*/
|
||||
reagent.impl.batching.RenderQueue = (function (scheduled_QMARK_){
|
||||
this.scheduled_QMARK_ = scheduled_QMARK_;
|
||||
});
|
||||
reagent.impl.batching.RenderQueue.prototype.run_funs = (function (k){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
var temp__5461__auto__ = (this$[k]);
|
||||
if((temp__5461__auto__ == null)){
|
||||
return null;
|
||||
} else {
|
||||
var fs = temp__5461__auto__;
|
||||
(this$[k] = null);
|
||||
|
||||
var n__9827__auto__ = fs.length;
|
||||
var i = (0);
|
||||
while(true){
|
||||
if((i < n__9827__auto__)){
|
||||
var fexpr__14540_14542 = (fs[i]);
|
||||
(fexpr__14540_14542.cljs$core$IFn$_invoke$arity$0 ? fexpr__14540_14542.cljs$core$IFn$_invoke$arity$0() : fexpr__14540_14542.call(null));
|
||||
|
||||
var G__14543 = (i + (1));
|
||||
i = G__14543;
|
||||
continue;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.flush_after_render = (function (){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
return this$.run_funs("afterRender");
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.queue_render = (function (c){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
return this$.enqueue("componentQueue",c);
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.schedule = (function (){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
if(self__.scheduled_QMARK_){
|
||||
return null;
|
||||
} else {
|
||||
self__.scheduled_QMARK_ = true;
|
||||
|
||||
var G__14541 = ((function (this$){
|
||||
return (function (){
|
||||
return this$.run_queues();
|
||||
});})(this$))
|
||||
;
|
||||
return (reagent.impl.batching.next_tick.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.batching.next_tick.cljs$core$IFn$_invoke$arity$1(G__14541) : reagent.impl.batching.next_tick.call(null,G__14541));
|
||||
}
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.flush_queues = (function (){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
this$.run_funs("beforeFlush");
|
||||
|
||||
reagent.impl.batching.ratom_flush();
|
||||
|
||||
var temp__5461__auto___14544 = (this$["componentQueue"]);
|
||||
if((temp__5461__auto___14544 == null)){
|
||||
} else {
|
||||
var cs_14545 = temp__5461__auto___14544;
|
||||
(this$["componentQueue"] = null);
|
||||
|
||||
reagent.impl.batching.run_queue(cs_14545);
|
||||
}
|
||||
|
||||
return this$.flush_after_render();
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.run_queues = (function (){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
self__.scheduled_QMARK_ = false;
|
||||
|
||||
return this$.flush_queues();
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.enqueue = (function (k,f){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
if(cljs.core.truth_(f)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Enqueued function"," must not be nil"].join('')),"\n","f"].join('')));
|
||||
}
|
||||
|
||||
if(((this$[k]) == null)){
|
||||
(this$[k] = []);
|
||||
} else {
|
||||
}
|
||||
|
||||
(this$[k]).push(f);
|
||||
|
||||
return this$.schedule();
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.add_before_flush = (function (f){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
return this$.enqueue("beforeFlush",f);
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.prototype.add_after_render = (function (f){
|
||||
var self__ = this;
|
||||
var this$ = this;
|
||||
return this$.enqueue("afterRender",f);
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.getBasis = (function (){
|
||||
return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$scheduled_QMARK_,new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$tag,cljs.core.cst$sym$boolean,cljs.core.cst$kw$mutable,true], null))], null);
|
||||
});
|
||||
|
||||
reagent.impl.batching.RenderQueue.cljs$lang$type = true;
|
||||
|
||||
reagent.impl.batching.RenderQueue.cljs$lang$ctorStr = "reagent.impl.batching/RenderQueue";
|
||||
|
||||
reagent.impl.batching.RenderQueue.cljs$lang$ctorPrWriter = (function (this__9453__auto__,writer__9454__auto__,opt__9455__auto__){
|
||||
return cljs.core._write(writer__9454__auto__,"reagent.impl.batching/RenderQueue");
|
||||
});
|
||||
|
||||
reagent.impl.batching.__GT_RenderQueue = (function reagent$impl$batching$__GT_RenderQueue(scheduled_QMARK_){
|
||||
return (new reagent.impl.batching.RenderQueue(scheduled_QMARK_));
|
||||
});
|
||||
|
||||
if(typeof reagent.impl.batching.render_queue !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.batching.render_queue = reagent.impl.batching.__GT_RenderQueue(false);
|
||||
}
|
||||
reagent.impl.batching.flush = (function reagent$impl$batching$flush(){
|
||||
return reagent.impl.batching.render_queue.flush_queues();
|
||||
});
|
||||
reagent.impl.batching.flush_after_render = (function reagent$impl$batching$flush_after_render(){
|
||||
return reagent.impl.batching.render_queue.flush_after_render();
|
||||
});
|
||||
reagent.impl.batching.queue_render = (function reagent$impl$batching$queue_render(c){
|
||||
if(cljs.core.truth_((c["cljsIsDirty"]))){
|
||||
return null;
|
||||
} else {
|
||||
(c["cljsIsDirty"] = true);
|
||||
|
||||
return reagent.impl.batching.render_queue.queue_render(c);
|
||||
}
|
||||
});
|
||||
reagent.impl.batching.mark_rendered = (function reagent$impl$batching$mark_rendered(c){
|
||||
return (c["cljsIsDirty"] = false);
|
||||
});
|
||||
reagent.impl.batching.do_before_flush = (function reagent$impl$batching$do_before_flush(f){
|
||||
return reagent.impl.batching.render_queue.add_before_flush(f);
|
||||
});
|
||||
reagent.impl.batching.do_after_render = (function reagent$impl$batching$do_after_render(f){
|
||||
return reagent.impl.batching.render_queue.add_after_render(f);
|
||||
});
|
||||
reagent.impl.batching.schedule = (function reagent$impl$batching$schedule(){
|
||||
if(reagent.impl.batching.render_queue.scheduled_QMARK_ === false){
|
||||
return reagent.impl.batching.render_queue.schedule();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,316 @@
|
||||
(ns reagent.impl.component
|
||||
(:require [reagent.impl.util :as util]
|
||||
[reagent.impl.batching :as batch]
|
||||
[reagent.ratom :as ratom]
|
||||
[reagent.interop :refer-macros [$ $!]]
|
||||
[reagent.debug :refer-macros [dbg prn dev? warn error warn-unless
|
||||
assert-callable]]))
|
||||
|
||||
(declare ^:dynamic *current-component*)
|
||||
|
||||
|
||||
;;; Argv access
|
||||
|
||||
(defn shallow-obj-to-map [o]
|
||||
(let [ks (js-keys o)
|
||||
len (alength ks)]
|
||||
(loop [m {} i 0]
|
||||
(if (< i len)
|
||||
(let [k (aget ks i)]
|
||||
(recur (assoc m (keyword k) (aget o k)) (inc i)))
|
||||
m))))
|
||||
|
||||
(defn extract-props [v]
|
||||
(let [p (nth v 1 nil)]
|
||||
(if (map? p) p)))
|
||||
|
||||
(defn extract-children [v]
|
||||
(let [p (nth v 1 nil)
|
||||
first-child (if (or (nil? p) (map? p)) 2 1)]
|
||||
(if (> (count v) first-child)
|
||||
(subvec v first-child))))
|
||||
|
||||
(defn props-argv [c p]
|
||||
(if-some [a ($ p :argv)]
|
||||
a
|
||||
[(.-constructor c) (shallow-obj-to-map p)]))
|
||||
|
||||
(defn get-argv [c]
|
||||
(props-argv c ($ c :props)))
|
||||
|
||||
(defn get-props [c]
|
||||
(let [p ($ c :props)]
|
||||
(if-some [v ($ p :argv)]
|
||||
(extract-props v)
|
||||
(shallow-obj-to-map p))))
|
||||
|
||||
(defn get-children [c]
|
||||
(let [p ($ c :props)]
|
||||
(if-some [v ($ p :argv)]
|
||||
(extract-children v)
|
||||
(->> ($ p :children)
|
||||
($ util/react Children.toArray)
|
||||
(into [])))))
|
||||
|
||||
(defn ^boolean reagent-class? [c]
|
||||
(and (fn? c)
|
||||
(some? (some-> c .-prototype ($ :reagentRender)))))
|
||||
|
||||
(defn ^boolean react-class? [c]
|
||||
(and (fn? c)
|
||||
(some? (some-> c .-prototype ($ :render)))))
|
||||
|
||||
(defn ^boolean reagent-component? [c]
|
||||
(some? ($ c :reagentRender)))
|
||||
|
||||
(defn cached-react-class [c]
|
||||
($ c :cljsReactClass))
|
||||
|
||||
(defn cache-react-class [c constructor]
|
||||
($! c :cljsReactClass constructor))
|
||||
|
||||
|
||||
;;; State
|
||||
|
||||
(defn state-atom [this]
|
||||
(let [sa ($ this :cljsState)]
|
||||
(if-not (nil? sa)
|
||||
sa
|
||||
($! this :cljsState (ratom/atom nil)))))
|
||||
|
||||
;; avoid circular dependency: this gets set from template.cljs
|
||||
(defonce as-element nil)
|
||||
|
||||
|
||||
;;; Rendering
|
||||
|
||||
(defn wrap-render [c]
|
||||
(let [f ($ c :reagentRender)
|
||||
_ (assert-callable f)
|
||||
res (if (true? ($ c :cljsLegacyRender))
|
||||
(.call f c c)
|
||||
(let [v (get-argv c)
|
||||
n (count v)]
|
||||
(case n
|
||||
1 (.call f c)
|
||||
2 (.call f c (nth v 1))
|
||||
3 (.call f c (nth v 1) (nth v 2))
|
||||
4 (.call f c (nth v 1) (nth v 2) (nth v 3))
|
||||
5 (.call f c (nth v 1) (nth v 2) (nth v 3) (nth v 4))
|
||||
(.apply f c (.slice (into-array v) 1)))))]
|
||||
(cond
|
||||
(vector? res) (as-element res)
|
||||
(ifn? res) (let [f (if (reagent-class? res)
|
||||
(fn [& args]
|
||||
(as-element (apply vector res args)))
|
||||
res)]
|
||||
($! c :reagentRender f)
|
||||
(recur c))
|
||||
:else res)))
|
||||
|
||||
(declare comp-name)
|
||||
|
||||
(defn do-render [c]
|
||||
(binding [*current-component* c]
|
||||
(if (dev?)
|
||||
;; Log errors, without using try/catch (and mess up call stack)
|
||||
(let [ok (array false)]
|
||||
(try
|
||||
(let [res (wrap-render c)]
|
||||
(aset ok 0 true)
|
||||
res)
|
||||
(finally
|
||||
(when-not (aget ok 0)
|
||||
(error (str "Error rendering component"
|
||||
(comp-name)))))))
|
||||
(wrap-render c))))
|
||||
|
||||
|
||||
;;; Method wrapping
|
||||
|
||||
(def rat-opts {:no-cache true})
|
||||
|
||||
(def static-fns
|
||||
{:render
|
||||
(fn render []
|
||||
(this-as c (if util/*non-reactive*
|
||||
(do-render c)
|
||||
(let [rat ($ c :cljsRatom)]
|
||||
(batch/mark-rendered c)
|
||||
(if (nil? rat)
|
||||
(ratom/run-in-reaction #(do-render c) c "cljsRatom"
|
||||
batch/queue-render rat-opts)
|
||||
(._run rat false))))))})
|
||||
|
||||
(defn custom-wrapper [key f]
|
||||
(case key
|
||||
:getDefaultProps
|
||||
(throw (js/Error. "getDefaultProps not supported"))
|
||||
|
||||
:getInitialState
|
||||
(fn getInitialState []
|
||||
(this-as c (reset! (state-atom c) (.call f c c))))
|
||||
|
||||
:componentWillReceiveProps
|
||||
(fn componentWillReceiveProps [nextprops]
|
||||
(this-as c (.call f c c (props-argv c nextprops))))
|
||||
|
||||
:shouldComponentUpdate
|
||||
(fn shouldComponentUpdate [nextprops nextstate]
|
||||
(or util/*always-update*
|
||||
(this-as c
|
||||
;; Don't care about nextstate here, we use forceUpdate
|
||||
;; when only when state has changed anyway.
|
||||
(let [old-argv ($ c :props.argv)
|
||||
new-argv ($ nextprops :argv)
|
||||
noargv (or (nil? old-argv) (nil? new-argv))]
|
||||
(cond
|
||||
(nil? f) (or noargv (not= old-argv new-argv))
|
||||
noargv (.call f c c (get-argv c) (props-argv c nextprops))
|
||||
:else (.call f c c old-argv new-argv))))))
|
||||
|
||||
:componentWillUpdate
|
||||
(fn componentWillUpdate [nextprops]
|
||||
(this-as c (.call f c c (props-argv c nextprops))))
|
||||
|
||||
:componentDidUpdate
|
||||
(fn componentDidUpdate [oldprops]
|
||||
(this-as c (.call f c c (props-argv c oldprops))))
|
||||
|
||||
:componentWillMount
|
||||
(fn componentWillMount []
|
||||
(this-as c
|
||||
($! c :cljsMountOrder (batch/next-mount-count))
|
||||
(when-not (nil? f)
|
||||
(.call f c c))))
|
||||
|
||||
:componentDidMount
|
||||
(fn componentDidMount []
|
||||
(this-as c (.call f c c)))
|
||||
|
||||
:componentWillUnmount
|
||||
(fn componentWillUnmount []
|
||||
(this-as c
|
||||
(some-> ($ c :cljsRatom)
|
||||
ratom/dispose!)
|
||||
(batch/mark-rendered c)
|
||||
(when-not (nil? f)
|
||||
(.call f c c))))
|
||||
|
||||
nil))
|
||||
|
||||
(defn get-wrapper [key f name]
|
||||
(let [wrap (custom-wrapper key f)]
|
||||
(when (and wrap f)
|
||||
(assert-callable f))
|
||||
(or wrap f)))
|
||||
|
||||
(def obligatory {:shouldComponentUpdate nil
|
||||
:componentWillMount nil
|
||||
:componentWillUnmount nil})
|
||||
|
||||
(def dash-to-camel (util/memoize-1 util/dash-to-camel))
|
||||
|
||||
(defn camelify-map-keys [fun-map]
|
||||
(reduce-kv (fn [m k v]
|
||||
(assoc m (-> k dash-to-camel keyword) v))
|
||||
{} fun-map))
|
||||
|
||||
(defn add-obligatory [fun-map]
|
||||
(merge obligatory fun-map))
|
||||
|
||||
(defn wrap-funs [fmap]
|
||||
(when (dev?)
|
||||
(let [renders (select-keys fmap [:render :reagentRender :componentFunction])
|
||||
render-fun (-> renders vals first)]
|
||||
(assert (pos? (count renders)) "Missing reagent-render")
|
||||
(assert (== 1 (count renders)) "Too many render functions supplied")
|
||||
(assert-callable render-fun)))
|
||||
(let [render-fun (or (:reagentRender fmap)
|
||||
(:componentFunction fmap))
|
||||
legacy-render (nil? render-fun)
|
||||
render-fun (or render-fun
|
||||
(:render fmap))
|
||||
name (str (or (:displayName fmap)
|
||||
(util/fun-name render-fun)))
|
||||
name (case name
|
||||
"" (str (gensym "reagent"))
|
||||
name)
|
||||
fmap (reduce-kv (fn [m k v]
|
||||
(assoc m k (get-wrapper k v name)))
|
||||
{} fmap)]
|
||||
(assoc fmap
|
||||
:displayName name
|
||||
:autobind false
|
||||
:cljsLegacyRender legacy-render
|
||||
:reagentRender render-fun
|
||||
:render (:render static-fns))))
|
||||
|
||||
(defn map-to-js [m]
|
||||
(reduce-kv (fn [o k v]
|
||||
(doto o
|
||||
(aset (name k) v)))
|
||||
#js{} m))
|
||||
|
||||
(defn cljsify [body]
|
||||
(-> body
|
||||
camelify-map-keys
|
||||
add-obligatory
|
||||
wrap-funs
|
||||
map-to-js))
|
||||
|
||||
(defn create-class [body]
|
||||
{:pre [(map? body)]}
|
||||
(->> body
|
||||
cljsify
|
||||
util/create-class))
|
||||
|
||||
(defn component-path [c]
|
||||
(let [elem (some-> (or (some-> c ($ :_reactInternalInstance))
|
||||
c)
|
||||
($ :_currentElement))
|
||||
name (some-> elem
|
||||
($ :type)
|
||||
($ :displayName))
|
||||
path (some-> elem
|
||||
($ :_owner)
|
||||
component-path
|
||||
(str " > "))
|
||||
res (str path name)]
|
||||
(when-not (empty? res) res)))
|
||||
|
||||
(defn comp-name []
|
||||
(if (dev?)
|
||||
(let [c *current-component*
|
||||
n (or (component-path c)
|
||||
(some-> c .-constructor util/fun-name))]
|
||||
(if-not (empty? n)
|
||||
(str " (in " n ")")
|
||||
""))
|
||||
""))
|
||||
|
||||
(defn fn-to-class [f]
|
||||
(assert-callable f)
|
||||
(warn-unless (not (and (react-class? f)
|
||||
(not (reagent-class? f))))
|
||||
"Using native React classes directly in Hiccup forms "
|
||||
"is not supported. Use create-element or "
|
||||
"adapt-react-class instead: " (let [n (util/fun-name f)]
|
||||
(if (empty? n) f n))
|
||||
(comp-name))
|
||||
(if (reagent-class? f)
|
||||
(cache-react-class f f)
|
||||
(let [spec (meta f)
|
||||
withrender (assoc spec :reagent-render f)
|
||||
res (create-class withrender)]
|
||||
(cache-react-class f res))))
|
||||
|
||||
(defn as-class [tag]
|
||||
(if-some [cached-class (cached-react-class tag)]
|
||||
cached-class
|
||||
(fn-to-class tag)))
|
||||
|
||||
(defn reactify-component [comp]
|
||||
(if (react-class? comp)
|
||||
comp
|
||||
(as-class comp)))
|
||||
@@ -0,0 +1,574 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.impl.component');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('reagent.impl.util');
|
||||
goog.require('reagent.impl.batching');
|
||||
goog.require('reagent.ratom');
|
||||
goog.require('reagent.interop');
|
||||
goog.require('reagent.debug');
|
||||
reagent.impl.component.shallow_obj_to_map = (function reagent$impl$component$shallow_obj_to_map(o){
|
||||
var ks = cljs.core.js_keys(o);
|
||||
var len = ks.length;
|
||||
var m = cljs.core.PersistentArrayMap.EMPTY;
|
||||
var i = (0);
|
||||
while(true){
|
||||
if((i < len)){
|
||||
var k = (ks[i]);
|
||||
var G__14792 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(k),(o[k]));
|
||||
var G__14793 = (i + (1));
|
||||
m = G__14792;
|
||||
i = G__14793;
|
||||
continue;
|
||||
} else {
|
||||
return m;
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.extract_props = (function reagent$impl$component$extract_props(v){
|
||||
var p = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(v,(1),null);
|
||||
if(cljs.core.map_QMARK_(p)){
|
||||
return p;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.extract_children = (function reagent$impl$component$extract_children(v){
|
||||
var p = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(v,(1),null);
|
||||
var first_child = ((((p == null)) || (cljs.core.map_QMARK_(p)))?(2):(1));
|
||||
if((cljs.core.count(v) > first_child)){
|
||||
return cljs.core.subvec.cljs$core$IFn$_invoke$arity$2(v,first_child);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.props_argv = (function reagent$impl$component$props_argv(c,p){
|
||||
var temp__5459__auto__ = (p["argv"]);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [c.constructor,reagent.impl.component.shallow_obj_to_map(p)], null);
|
||||
} else {
|
||||
var a = temp__5459__auto__;
|
||||
return a;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.get_argv = (function reagent$impl$component$get_argv(c){
|
||||
return reagent.impl.component.props_argv(c,(c["props"]));
|
||||
});
|
||||
reagent.impl.component.get_props = (function reagent$impl$component$get_props(c){
|
||||
var p = (c["props"]);
|
||||
var temp__5459__auto__ = (p["argv"]);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return reagent.impl.component.shallow_obj_to_map(p);
|
||||
} else {
|
||||
var v = temp__5459__auto__;
|
||||
return reagent.impl.component.extract_props(v);
|
||||
}
|
||||
});
|
||||
reagent.impl.component.get_children = (function reagent$impl$component$get_children(c){
|
||||
var p = (c["props"]);
|
||||
var temp__5459__auto__ = (p["argv"]);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,(reagent.impl.util.react["Children"]["toArray"])((p["children"])));
|
||||
} else {
|
||||
var v = temp__5459__auto__;
|
||||
return reagent.impl.component.extract_children(v);
|
||||
}
|
||||
});
|
||||
reagent.impl.component.reagent_class_QMARK_ = (function reagent$impl$component$reagent_class_QMARK_(c){
|
||||
return (cljs.core.fn_QMARK_(c)) && (!(((function (){var G__14795 = c;
|
||||
var G__14795__$1 = (((G__14795 == null))?null:G__14795.prototype);
|
||||
if((G__14795__$1 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (G__14795__$1["reagentRender"]);
|
||||
}
|
||||
})() == null)));
|
||||
});
|
||||
reagent.impl.component.react_class_QMARK_ = (function reagent$impl$component$react_class_QMARK_(c){
|
||||
return (cljs.core.fn_QMARK_(c)) && (!(((function (){var G__14797 = c;
|
||||
var G__14797__$1 = (((G__14797 == null))?null:G__14797.prototype);
|
||||
if((G__14797__$1 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (G__14797__$1["render"]);
|
||||
}
|
||||
})() == null)));
|
||||
});
|
||||
reagent.impl.component.reagent_component_QMARK_ = (function reagent$impl$component$reagent_component_QMARK_(c){
|
||||
return !(((c["reagentRender"]) == null));
|
||||
});
|
||||
reagent.impl.component.cached_react_class = (function reagent$impl$component$cached_react_class(c){
|
||||
return (c["cljsReactClass"]);
|
||||
});
|
||||
reagent.impl.component.cache_react_class = (function reagent$impl$component$cache_react_class(c,constructor$){
|
||||
return (c["cljsReactClass"] = constructor$);
|
||||
});
|
||||
reagent.impl.component.state_atom = (function reagent$impl$component$state_atom(this$){
|
||||
var sa = (this$["cljsState"]);
|
||||
if(!((sa == null))){
|
||||
return sa;
|
||||
} else {
|
||||
return (this$["cljsState"] = reagent.ratom.atom.cljs$core$IFn$_invoke$arity$1(null));
|
||||
}
|
||||
});
|
||||
if(typeof reagent.impl.component.as_element !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.component.as_element = null;
|
||||
}
|
||||
reagent.impl.component.wrap_render = (function reagent$impl$component$wrap_render(c){
|
||||
while(true){
|
||||
var f = (c["reagentRender"]);
|
||||
var _ = ((cljs.core.ifn_QMARK_(f))?null:(function(){throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected something callable, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([f], 0)))].join('')),"\n","(clojure.core/ifn? f)"].join('')))})());
|
||||
var res = (((c["cljsLegacyRender"]) === true)?f.call(c,c):(function (){var v = reagent.impl.component.get_argv(c);
|
||||
var n = cljs.core.count(v);
|
||||
var G__14798 = n;
|
||||
switch (G__14798) {
|
||||
case (1):
|
||||
return f.call(c);
|
||||
|
||||
break;
|
||||
case (2):
|
||||
return f.call(c,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(1)));
|
||||
|
||||
break;
|
||||
case (3):
|
||||
return f.call(c,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(1)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(2)));
|
||||
|
||||
break;
|
||||
case (4):
|
||||
return f.call(c,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(1)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(2)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(3)));
|
||||
|
||||
break;
|
||||
case (5):
|
||||
return f.call(c,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(1)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(2)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(3)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,(4)));
|
||||
|
||||
break;
|
||||
default:
|
||||
return f.apply(c,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(v).slice((1)));
|
||||
|
||||
}
|
||||
})());
|
||||
if(cljs.core.vector_QMARK_(res)){
|
||||
return (reagent.impl.component.as_element.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.component.as_element.cljs$core$IFn$_invoke$arity$1(res) : reagent.impl.component.as_element.call(null,res));
|
||||
} else {
|
||||
if(cljs.core.ifn_QMARK_(res)){
|
||||
var f__$1 = ((reagent.impl.component.reagent_class_QMARK_(res))?((function (c,f,_,res){
|
||||
return (function() {
|
||||
var G__14801__delegate = function (args){
|
||||
var G__14799 = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.vector,res,args);
|
||||
return (reagent.impl.component.as_element.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.component.as_element.cljs$core$IFn$_invoke$arity$1(G__14799) : reagent.impl.component.as_element.call(null,G__14799));
|
||||
};
|
||||
var G__14801 = function (var_args){
|
||||
var args = null;
|
||||
if (arguments.length > 0) {
|
||||
var G__14802__i = 0, G__14802__a = new Array(arguments.length - 0);
|
||||
while (G__14802__i < G__14802__a.length) {G__14802__a[G__14802__i] = arguments[G__14802__i + 0]; ++G__14802__i;}
|
||||
args = new cljs.core.IndexedSeq(G__14802__a,0,null);
|
||||
}
|
||||
return G__14801__delegate.call(this,args);};
|
||||
G__14801.cljs$lang$maxFixedArity = 0;
|
||||
G__14801.cljs$lang$applyTo = (function (arglist__14803){
|
||||
var args = cljs.core.seq(arglist__14803);
|
||||
return G__14801__delegate(args);
|
||||
});
|
||||
G__14801.cljs$core$IFn$_invoke$arity$variadic = G__14801__delegate;
|
||||
return G__14801;
|
||||
})()
|
||||
;})(c,f,_,res))
|
||||
:res);
|
||||
(c["reagentRender"] = f__$1);
|
||||
|
||||
var G__14804 = c;
|
||||
c = G__14804;
|
||||
continue;
|
||||
} else {
|
||||
return res;
|
||||
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.do_render = (function reagent$impl$component$do_render(c){
|
||||
var _STAR_current_component_STAR_14805 = reagent.impl.component._STAR_current_component_STAR_;
|
||||
reagent.impl.component._STAR_current_component_STAR_ = c;
|
||||
|
||||
try{var ok = [false];
|
||||
try{var res = reagent.impl.component.wrap_render(c);
|
||||
(ok[(0)] = true);
|
||||
|
||||
return res;
|
||||
}finally {if(cljs.core.truth_((ok[(0)]))){
|
||||
} else {
|
||||
if(cljs.core.truth_(reagent.debug.has_console)){
|
||||
(cljs.core.truth_(reagent.debug.tracking)?reagent.debug.track_console:console).error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Error rendering component",cljs.core.str.cljs$core$IFn$_invoke$arity$1((reagent.impl.component.comp_name.cljs$core$IFn$_invoke$arity$0 ? reagent.impl.component.comp_name.cljs$core$IFn$_invoke$arity$0() : reagent.impl.component.comp_name.call(null)))].join(''))].join(''));
|
||||
} else {
|
||||
}
|
||||
}
|
||||
}
|
||||
}finally {reagent.impl.component._STAR_current_component_STAR_ = _STAR_current_component_STAR_14805;
|
||||
}});
|
||||
reagent.impl.component.rat_opts = new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$no_DASH_cache,true], null);
|
||||
reagent.impl.component.static_fns = new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$render,(function reagent$impl$component$render(){
|
||||
var c = this;
|
||||
if(reagent.impl.util._STAR_non_reactive_STAR_){
|
||||
return reagent.impl.component.do_render(c);
|
||||
} else {
|
||||
var rat = (c["cljsRatom"]);
|
||||
reagent.impl.batching.mark_rendered(c);
|
||||
|
||||
if((rat == null)){
|
||||
return reagent.ratom.run_in_reaction(((function (rat,c){
|
||||
return (function (){
|
||||
return reagent.impl.component.do_render(c);
|
||||
});})(rat,c))
|
||||
,c,"cljsRatom",reagent.impl.batching.queue_render,reagent.impl.component.rat_opts);
|
||||
} else {
|
||||
return rat._run(false);
|
||||
}
|
||||
}
|
||||
})], null);
|
||||
reagent.impl.component.custom_wrapper = (function reagent$impl$component$custom_wrapper(key,f){
|
||||
var G__14806 = key;
|
||||
var G__14806__$1 = (((G__14806 instanceof cljs.core.Keyword))?G__14806.fqn:null);
|
||||
switch (G__14806__$1) {
|
||||
case "getDefaultProps":
|
||||
throw (new Error("getDefaultProps not supported"));
|
||||
|
||||
break;
|
||||
case "getInitialState":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_getInitialState(){
|
||||
var c = this;
|
||||
return cljs.core.reset_BANG_(reagent.impl.component.state_atom(c),f.call(c,c));
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentWillReceiveProps":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentWillReceiveProps(nextprops){
|
||||
var c = this;
|
||||
return f.call(c,c,reagent.impl.component.props_argv(c,nextprops));
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "shouldComponentUpdate":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_shouldComponentUpdate(nextprops,nextstate){
|
||||
var or__8782__auto__ = reagent.impl.util._STAR_always_update_STAR_;
|
||||
if(or__8782__auto__){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
var c = this;
|
||||
var old_argv = (c["props"]["argv"]);
|
||||
var new_argv = (nextprops["argv"]);
|
||||
var noargv = ((old_argv == null)) || ((new_argv == null));
|
||||
if((f == null)){
|
||||
return (noargv) || (cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(old_argv,new_argv));
|
||||
} else {
|
||||
if(noargv){
|
||||
return f.call(c,c,reagent.impl.component.get_argv(c),reagent.impl.component.props_argv(c,nextprops));
|
||||
} else {
|
||||
return f.call(c,c,old_argv,new_argv);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentWillUpdate":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentWillUpdate(nextprops){
|
||||
var c = this;
|
||||
return f.call(c,c,reagent.impl.component.props_argv(c,nextprops));
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentDidUpdate":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentDidUpdate(oldprops){
|
||||
var c = this;
|
||||
return f.call(c,c,reagent.impl.component.props_argv(c,oldprops));
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentWillMount":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentWillMount(){
|
||||
var c = this;
|
||||
(c["cljsMountOrder"] = reagent.impl.batching.next_mount_count());
|
||||
|
||||
if((f == null)){
|
||||
return null;
|
||||
} else {
|
||||
return f.call(c,c);
|
||||
}
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentDidMount":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentDidMount(){
|
||||
var c = this;
|
||||
return f.call(c,c);
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
case "componentWillUnmount":
|
||||
return ((function (G__14806,G__14806__$1){
|
||||
return (function reagent$impl$component$custom_wrapper_$_componentWillUnmount(){
|
||||
var c = this;
|
||||
var G__14807_14809 = (c["cljsRatom"]);
|
||||
if((G__14807_14809 == null)){
|
||||
} else {
|
||||
reagent.ratom.dispose_BANG_(G__14807_14809);
|
||||
}
|
||||
|
||||
reagent.impl.batching.mark_rendered(c);
|
||||
|
||||
if((f == null)){
|
||||
return null;
|
||||
} else {
|
||||
return f.call(c,c);
|
||||
}
|
||||
});
|
||||
;})(G__14806,G__14806__$1))
|
||||
|
||||
break;
|
||||
default:
|
||||
return null;
|
||||
|
||||
}
|
||||
});
|
||||
reagent.impl.component.get_wrapper = (function reagent$impl$component$get_wrapper(key,f,name){
|
||||
var wrap = reagent.impl.component.custom_wrapper(key,f);
|
||||
if(cljs.core.truth_((function (){var and__8770__auto__ = wrap;
|
||||
if(cljs.core.truth_(and__8770__auto__)){
|
||||
return f;
|
||||
} else {
|
||||
return and__8770__auto__;
|
||||
}
|
||||
})())){
|
||||
if(cljs.core.ifn_QMARK_(f)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected something callable, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([f], 0)))].join('')),"\n","(clojure.core/ifn? f)"].join('')));
|
||||
}
|
||||
} else {
|
||||
}
|
||||
|
||||
var or__8782__auto__ = wrap;
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return f;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.obligatory = new cljs.core.PersistentArrayMap(null, 3, [cljs.core.cst$kw$shouldComponentUpdate,null,cljs.core.cst$kw$componentWillMount,null,cljs.core.cst$kw$componentWillUnmount,null], null);
|
||||
reagent.impl.component.dash_to_camel = reagent.impl.util.memoize_1(reagent.impl.util.dash_to_camel);
|
||||
reagent.impl.component.camelify_map_keys = (function reagent$impl$component$camelify_map_keys(fun_map){
|
||||
return cljs.core.reduce_kv((function (m,k,v){
|
||||
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,cljs.core.keyword.cljs$core$IFn$_invoke$arity$1((reagent.impl.component.dash_to_camel.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.component.dash_to_camel.cljs$core$IFn$_invoke$arity$1(k) : reagent.impl.component.dash_to_camel.call(null,k))),v);
|
||||
}),cljs.core.PersistentArrayMap.EMPTY,fun_map);
|
||||
});
|
||||
reagent.impl.component.add_obligatory = (function reagent$impl$component$add_obligatory(fun_map){
|
||||
return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([reagent.impl.component.obligatory,fun_map], 0));
|
||||
});
|
||||
reagent.impl.component.wrap_funs = (function reagent$impl$component$wrap_funs(fmap){
|
||||
var renders_14811 = cljs.core.select_keys(fmap,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$render,cljs.core.cst$kw$reagentRender,cljs.core.cst$kw$componentFunction], null));
|
||||
var render_fun_14812 = cljs.core.first(cljs.core.vals(renders_14811));
|
||||
if((cljs.core.count(renders_14811) > (0))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ","Missing reagent-render","\n","(pos? (count renders))"].join('')));
|
||||
}
|
||||
|
||||
if(((1) === cljs.core.count(renders_14811))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ","Too many render functions supplied","\n","(== 1 (count renders))"].join('')));
|
||||
}
|
||||
|
||||
if(cljs.core.ifn_QMARK_(render_fun_14812)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected something callable, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([render_fun_14812], 0)))].join('')),"\n","(clojure.core/ifn? render-fun)"].join('')));
|
||||
}
|
||||
|
||||
|
||||
var render_fun = (function (){var or__8782__auto__ = cljs.core.cst$kw$reagentRender.cljs$core$IFn$_invoke$arity$1(fmap);
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return cljs.core.cst$kw$componentFunction.cljs$core$IFn$_invoke$arity$1(fmap);
|
||||
}
|
||||
})();
|
||||
var legacy_render = (render_fun == null);
|
||||
var render_fun__$1 = (function (){var or__8782__auto__ = render_fun;
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return cljs.core.cst$kw$render.cljs$core$IFn$_invoke$arity$1(fmap);
|
||||
}
|
||||
})();
|
||||
var name = [cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var or__8782__auto__ = cljs.core.cst$kw$displayName.cljs$core$IFn$_invoke$arity$1(fmap);
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return reagent.impl.util.fun_name(render_fun__$1);
|
||||
}
|
||||
})())].join('');
|
||||
var name__$1 = (function (){var G__14810 = name;
|
||||
switch (G__14810) {
|
||||
case "":
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.gensym.cljs$core$IFn$_invoke$arity$1("reagent"))].join('');
|
||||
|
||||
break;
|
||||
default:
|
||||
return name;
|
||||
|
||||
}
|
||||
})();
|
||||
var fmap__$1 = cljs.core.reduce_kv(((function (render_fun,legacy_render,render_fun__$1,name,name__$1){
|
||||
return (function (m,k,v){
|
||||
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,reagent.impl.component.get_wrapper(k,v,name__$1));
|
||||
});})(render_fun,legacy_render,render_fun__$1,name,name__$1))
|
||||
,cljs.core.PersistentArrayMap.EMPTY,fmap);
|
||||
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(fmap__$1,cljs.core.cst$kw$displayName,name__$1,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$autobind,false,cljs.core.cst$kw$cljsLegacyRender,legacy_render,cljs.core.cst$kw$reagentRender,render_fun__$1,cljs.core.cst$kw$render,cljs.core.cst$kw$render.cljs$core$IFn$_invoke$arity$1(reagent.impl.component.static_fns)], 0));
|
||||
});
|
||||
reagent.impl.component.map_to_js = (function reagent$impl$component$map_to_js(m){
|
||||
return cljs.core.reduce_kv((function (o,k,v){
|
||||
var G__14814 = o;
|
||||
(G__14814[cljs.core.name(k)] = v);
|
||||
|
||||
return G__14814;
|
||||
}),({}),m);
|
||||
});
|
||||
reagent.impl.component.cljsify = (function reagent$impl$component$cljsify(body){
|
||||
return reagent.impl.component.map_to_js(reagent.impl.component.wrap_funs(reagent.impl.component.add_obligatory(reagent.impl.component.camelify_map_keys(body))));
|
||||
});
|
||||
reagent.impl.component.create_class = (function reagent$impl$component$create_class(body){
|
||||
if(cljs.core.map_QMARK_(body)){
|
||||
} else {
|
||||
throw (new Error("Assert failed: (map? body)"));
|
||||
}
|
||||
|
||||
var G__14815 = reagent.impl.component.cljsify(body);
|
||||
return (reagent.impl.util.create_class.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.util.create_class.cljs$core$IFn$_invoke$arity$1(G__14815) : reagent.impl.util.create_class.call(null,G__14815));
|
||||
});
|
||||
reagent.impl.component.component_path = (function reagent$impl$component$component_path(c){
|
||||
var elem = (function (){var G__14816 = (function (){var or__8782__auto__ = (function (){var G__14818 = c;
|
||||
if((G__14818 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (G__14818["_reactInternalInstance"]);
|
||||
}
|
||||
})();
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return c;
|
||||
}
|
||||
})();
|
||||
if((G__14816 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (G__14816["_currentElement"]);
|
||||
}
|
||||
})();
|
||||
var name = (function (){var G__14819 = elem;
|
||||
var G__14819__$1 = (((G__14819 == null))?null:(G__14819["type"]));
|
||||
if((G__14819__$1 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (G__14819__$1["displayName"]);
|
||||
}
|
||||
})();
|
||||
var path = (function (){var G__14820 = elem;
|
||||
var G__14820__$1 = (((G__14820 == null))?null:(G__14820["_owner"]));
|
||||
var G__14820__$2 = (((G__14820__$1 == null))?null:(reagent.impl.component.component_path.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.component.component_path.cljs$core$IFn$_invoke$arity$1(G__14820__$1) : reagent.impl.component.component_path.call(null,G__14820__$1)));
|
||||
if((G__14820__$2 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__14820__$2)," > "].join('');
|
||||
}
|
||||
})();
|
||||
var res = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(path),cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)].join('');
|
||||
if(cljs.core.empty_QMARK_(res)){
|
||||
return null;
|
||||
} else {
|
||||
return res;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.comp_name = (function reagent$impl$component$comp_name(){
|
||||
var c = reagent.impl.component._STAR_current_component_STAR_;
|
||||
var n = (function (){var or__8782__auto__ = reagent.impl.component.component_path(c);
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
var G__14821 = c;
|
||||
var G__14821__$1 = (((G__14821 == null))?null:G__14821.constructor);
|
||||
if((G__14821__$1 == null)){
|
||||
return null;
|
||||
} else {
|
||||
return reagent.impl.util.fun_name(G__14821__$1);
|
||||
}
|
||||
}
|
||||
})();
|
||||
if(!(cljs.core.empty_QMARK_(n))){
|
||||
return [" (in ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),")"].join('');
|
||||
} else {
|
||||
return "";
|
||||
}
|
||||
|
||||
});
|
||||
reagent.impl.component.fn_to_class = (function reagent$impl$component$fn_to_class(f){
|
||||
if(cljs.core.ifn_QMARK_(f)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Expected something callable, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([f], 0)))].join('')),"\n","(clojure.core/ifn? f)"].join('')));
|
||||
}
|
||||
|
||||
if(!(!((reagent.impl.component.react_class_QMARK_(f)) && (!(reagent.impl.component.reagent_class_QMARK_(f)))))){
|
||||
if(cljs.core.truth_(reagent.debug.has_console)){
|
||||
(cljs.core.truth_(reagent.debug.tracking)?reagent.debug.track_console:console).warn(["Warning: ","Using native React classes directly in Hiccup forms ","is not supported. Use create-element or ","adapt-react-class instead: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var n = reagent.impl.util.fun_name(f);
|
||||
if(cljs.core.empty_QMARK_(n)){
|
||||
return f;
|
||||
} else {
|
||||
return n;
|
||||
}
|
||||
})()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.component.comp_name())].join(''));
|
||||
} else {
|
||||
}
|
||||
} else {
|
||||
}
|
||||
|
||||
if(reagent.impl.component.reagent_class_QMARK_(f)){
|
||||
return reagent.impl.component.cache_react_class(f,f);
|
||||
} else {
|
||||
var spec = cljs.core.meta(f);
|
||||
var withrender = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(spec,cljs.core.cst$kw$reagent_DASH_render,f);
|
||||
var res = reagent.impl.component.create_class(withrender);
|
||||
return reagent.impl.component.cache_react_class(f,res);
|
||||
}
|
||||
});
|
||||
reagent.impl.component.as_class = (function reagent$impl$component$as_class(tag){
|
||||
var temp__5459__auto__ = reagent.impl.component.cached_react_class(tag);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return reagent.impl.component.fn_to_class(tag);
|
||||
} else {
|
||||
var cached_class = temp__5459__auto__;
|
||||
return cached_class;
|
||||
}
|
||||
});
|
||||
reagent.impl.component.reactify_component = (function reagent$impl$component$reactify_component(comp){
|
||||
if(reagent.impl.component.react_class_QMARK_(comp)){
|
||||
return comp;
|
||||
} else {
|
||||
return reagent.impl.component.as_class(comp);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,405 @@
|
||||
(ns reagent.impl.template
|
||||
(:require [clojure.string :as string]
|
||||
[clojure.walk :refer [prewalk]]
|
||||
[reagent.impl.util :as util :refer [is-client]]
|
||||
[reagent.impl.component :as comp]
|
||||
[reagent.impl.batching :as batch]
|
||||
[reagent.ratom :as ratom]
|
||||
[reagent.interop :refer-macros [$ $!]]
|
||||
[reagent.debug :refer-macros [dbg prn println log dev?
|
||||
warn warn-unless]]))
|
||||
|
||||
;; From Weavejester's Hiccup, via pump:
|
||||
(def ^{:doc "Regular expression that parses a CSS-style id and class
|
||||
from a tag name."}
|
||||
re-tag #"([^\s\.#]+)(?:#([^\s\.#]+))?(?:\.([^\s#]+))?")
|
||||
|
||||
(deftype NativeWrapper [])
|
||||
|
||||
|
||||
;;; Common utilities
|
||||
|
||||
(defn ^boolean named? [x]
|
||||
(or (keyword? x)
|
||||
(symbol? x)))
|
||||
|
||||
(defn ^boolean hiccup-tag? [x]
|
||||
(or (named? x)
|
||||
(string? x)))
|
||||
|
||||
(defn ^boolean valid-tag? [x]
|
||||
(or (hiccup-tag? x)
|
||||
(ifn? x)
|
||||
(instance? NativeWrapper x)))
|
||||
|
||||
|
||||
;;; Props conversion
|
||||
|
||||
(def prop-name-cache #js{:class "className"
|
||||
:for "htmlFor"
|
||||
:charset "charSet"})
|
||||
|
||||
(defn cache-get [o k]
|
||||
(when ^boolean (.hasOwnProperty o k)
|
||||
(aget o k)))
|
||||
|
||||
(defn cached-prop-name [k]
|
||||
(if (named? k)
|
||||
(if-some [k' (cache-get prop-name-cache (name k))]
|
||||
k'
|
||||
(aset prop-name-cache (name k)
|
||||
(util/dash-to-camel k)))
|
||||
k))
|
||||
|
||||
(defn ^boolean js-val? [x]
|
||||
(not (identical? "object" (goog/typeOf x))))
|
||||
|
||||
(declare convert-prop-value)
|
||||
|
||||
(defn kv-conv [o k v]
|
||||
(doto o
|
||||
(aset (cached-prop-name k)
|
||||
(convert-prop-value v))))
|
||||
|
||||
(defn convert-prop-value [x]
|
||||
(cond (js-val? x) x
|
||||
(named? x) (name x)
|
||||
(map? x) (reduce-kv kv-conv #js{} x)
|
||||
(coll? x) (clj->js x)
|
||||
(ifn? x) (fn [& args]
|
||||
(apply x args))
|
||||
:else (clj->js x)))
|
||||
|
||||
(defn oset [o k v]
|
||||
(doto (if (nil? o) #js{} o)
|
||||
(aset k v)))
|
||||
|
||||
(defn oget [o k]
|
||||
(if (nil? o) nil (aget o k)))
|
||||
|
||||
(defn set-id-class [p id-class]
|
||||
(let [id ($ id-class :id)
|
||||
p (if (and (some? id)
|
||||
(nil? (oget p "id")))
|
||||
(oset p "id" id)
|
||||
p)]
|
||||
(if-some [class ($ id-class :className)]
|
||||
(let [old (oget p "className")]
|
||||
(oset p "className" (if (nil? old)
|
||||
class
|
||||
(str class " " old))))
|
||||
p)))
|
||||
|
||||
(defn convert-props [props id-class]
|
||||
(-> props
|
||||
convert-prop-value
|
||||
(set-id-class id-class)))
|
||||
|
||||
|
||||
;;; Specialization for input components
|
||||
|
||||
;; This gets set from reagent.dom
|
||||
(defonce find-dom-node nil)
|
||||
|
||||
;; <input type="??" >
|
||||
;; The properites 'selectionStart' and 'selectionEnd' only exist on some inputs
|
||||
;; See: https://html.spec.whatwg.org/multipage/forms.html#do-not-apply
|
||||
(def these-inputs-have-selection-api #{"text" "textarea" "password" "search"
|
||||
"tel" "url"})
|
||||
|
||||
(defn ^boolean has-selection-api?
|
||||
[input-type]
|
||||
(contains? these-inputs-have-selection-api input-type))
|
||||
|
||||
(defn input-set-value [this]
|
||||
(when ($ this :cljsInputLive)
|
||||
($! this :cljsInputDirty false)
|
||||
(let [rendered-value ($ this :cljsRenderedValue)
|
||||
dom-value ($ this :cljsDOMValue)
|
||||
node (find-dom-node this)]
|
||||
(when (not= rendered-value dom-value)
|
||||
(if-not (and (identical? node ($ js/document :activeElement))
|
||||
(has-selection-api? ($ node :type))
|
||||
(string? rendered-value)
|
||||
(string? dom-value))
|
||||
;; just set the value, no need to worry about a cursor
|
||||
(do
|
||||
($! this :cljsDOMValue rendered-value)
|
||||
($! node :value rendered-value))
|
||||
|
||||
;; Setting "value" (below) moves the cursor position to the
|
||||
;; end which gives the user a jarring experience.
|
||||
;;
|
||||
;; But repositioning the cursor within the text, turns out to
|
||||
;; be quite a challenge because changes in the text can be
|
||||
;; triggered by various events like:
|
||||
;; - a validation function rejecting a user inputted char
|
||||
;; - the user enters a lower case char, but is transformed to
|
||||
;; upper.
|
||||
;; - the user selects multiple chars and deletes text
|
||||
;; - the user pastes in multiple chars, and some of them are
|
||||
;; rejected by a validator.
|
||||
;; - the user selects multiple chars and then types in a
|
||||
;; single new char to repalce them all.
|
||||
;; Coming up with a sane cursor repositioning strategy hasn't
|
||||
;; been easy ALTHOUGH in the end, it kinda fell out nicely,
|
||||
;; and it appears to sanely handle all the cases we could
|
||||
;; think of.
|
||||
;; So this is just a warning. The code below is simple
|
||||
;; enough, but if you are tempted to change it, be aware of
|
||||
;; all the scenarios you have handle.
|
||||
(let [node-value ($ node :value)]
|
||||
(if (not= node-value dom-value)
|
||||
;; IE has not notified us of the change yet, so check again later
|
||||
(batch/do-after-render #(input-set-value this))
|
||||
(let [existing-offset-from-end (- (count node-value)
|
||||
($ node :selectionStart))
|
||||
new-cursor-offset (- (count rendered-value)
|
||||
existing-offset-from-end)]
|
||||
($! this :cljsDOMValue rendered-value)
|
||||
($! node :value rendered-value)
|
||||
($! node :selectionStart new-cursor-offset)
|
||||
($! node :selectionEnd new-cursor-offset)))))))))
|
||||
|
||||
(defn input-handle-change [this on-change e]
|
||||
($! this :cljsDOMValue (-> e .-target .-value))
|
||||
;; Make sure the input is re-rendered, in case on-change
|
||||
;; wants to keep the value unchanged
|
||||
(when-not ($ this :cljsInputDirty)
|
||||
($! this :cljsInputDirty true)
|
||||
(batch/do-after-render #(input-set-value this)))
|
||||
(on-change e))
|
||||
|
||||
(defn input-render-setup [this jsprops]
|
||||
;; Don't rely on React for updating "controlled inputs", since it
|
||||
;; doesn't play well with async rendering (misses keystrokes).
|
||||
(when (and (some? jsprops)
|
||||
(.hasOwnProperty jsprops "onChange")
|
||||
(.hasOwnProperty jsprops "value"))
|
||||
(assert find-dom-node
|
||||
"reagent.dom needs to be loaded for controlled input to work")
|
||||
(let [v ($ jsprops :value)
|
||||
value (if (nil? v) "" v)
|
||||
on-change ($ jsprops :onChange)]
|
||||
(when-not ($ this :cljsInputLive)
|
||||
;; set initial value
|
||||
($! this :cljsInputLive true)
|
||||
($! this :cljsDOMValue value))
|
||||
($! this :cljsRenderedValue value)
|
||||
(js-delete jsprops "value")
|
||||
(doto jsprops
|
||||
($! :defaultValue value)
|
||||
($! :onChange #(input-handle-change this on-change %))))))
|
||||
|
||||
(defn input-unmount [this]
|
||||
($! this :cljsInputLive nil))
|
||||
|
||||
(defn ^boolean input-component? [x]
|
||||
(case x
|
||||
("input" "textarea") true
|
||||
false))
|
||||
|
||||
(def reagent-input-class nil)
|
||||
|
||||
(declare make-element)
|
||||
|
||||
(def input-spec
|
||||
{:display-name "ReagentInput"
|
||||
:component-did-update input-set-value
|
||||
:component-will-unmount input-unmount
|
||||
:reagent-render
|
||||
(fn [argv comp jsprops first-child]
|
||||
(let [this comp/*current-component*]
|
||||
(input-render-setup this jsprops)
|
||||
(make-element argv comp jsprops first-child)))})
|
||||
|
||||
(defn reagent-input []
|
||||
(when (nil? reagent-input-class)
|
||||
(set! reagent-input-class (comp/create-class input-spec)))
|
||||
reagent-input-class)
|
||||
|
||||
|
||||
;;; Conversion from Hiccup forms
|
||||
|
||||
(defn parse-tag [hiccup-tag]
|
||||
(let [[tag id class] (->> hiccup-tag name (re-matches re-tag) next)
|
||||
class (when-not (nil? class)
|
||||
(string/replace class #"\." " "))]
|
||||
(assert tag (str "Invalid tag: '" hiccup-tag "'"
|
||||
(comp/comp-name)))
|
||||
#js{:name tag
|
||||
:id id
|
||||
:className class}))
|
||||
|
||||
(defn try-get-key [x]
|
||||
;; try catch to avoid clojurescript peculiarity with
|
||||
;; sorted-maps with keys that are numbers
|
||||
(try (get x :key)
|
||||
(catch :default e)))
|
||||
|
||||
(defn get-key [x]
|
||||
(when (map? x)
|
||||
(try-get-key x)))
|
||||
|
||||
(defn key-from-vec [v]
|
||||
(if-some [k (-> (meta v) get-key)]
|
||||
k
|
||||
(-> v (nth 1 nil) get-key)))
|
||||
|
||||
(defn reag-element [tag v]
|
||||
(let [c (comp/as-class tag)
|
||||
jsprops #js{:argv v}]
|
||||
(when-some [key (key-from-vec v)]
|
||||
($! jsprops :key key))
|
||||
($ util/react createElement c jsprops)))
|
||||
|
||||
(defn adapt-react-class [c]
|
||||
(doto (->NativeWrapper)
|
||||
($! :name c)
|
||||
($! :id nil)
|
||||
($! :class nil)))
|
||||
|
||||
(def tag-name-cache #js{})
|
||||
|
||||
(defn cached-parse [x]
|
||||
(if-some [s (cache-get tag-name-cache x)]
|
||||
s
|
||||
(aset tag-name-cache x (parse-tag x))))
|
||||
|
||||
(declare as-element)
|
||||
|
||||
(defn native-element [parsed argv first]
|
||||
(let [comp ($ parsed :name)]
|
||||
(let [props (nth argv first nil)
|
||||
hasprops (or (nil? props) (map? props))
|
||||
jsprops (convert-props (if hasprops props) parsed)
|
||||
first-child (+ first (if hasprops 1 0))]
|
||||
(if (input-component? comp)
|
||||
(-> [(reagent-input) argv comp jsprops first-child]
|
||||
(with-meta (meta argv))
|
||||
as-element)
|
||||
(let [key (-> (meta argv) get-key)
|
||||
p (if (nil? key)
|
||||
jsprops
|
||||
(oset jsprops "key" key))]
|
||||
(make-element argv comp p first-child))))))
|
||||
|
||||
(defn str-coll [coll]
|
||||
(if (dev?)
|
||||
(str (prewalk (fn [x]
|
||||
(if (fn? x)
|
||||
(let [n (util/fun-name x)]
|
||||
(case n "" x (symbol n)))
|
||||
x)) coll))
|
||||
(str coll)))
|
||||
|
||||
(defn hiccup-err [v & msg]
|
||||
(str (apply str msg) ": " (str-coll v) "\n" (comp/comp-name)))
|
||||
|
||||
(defn vec-to-elem [v]
|
||||
(assert (pos? (count v)) (hiccup-err v "Hiccup form should not be empty"))
|
||||
(let [tag (nth v 0 nil)]
|
||||
(assert (valid-tag? tag) (hiccup-err v "Invalid Hiccup form"))
|
||||
(cond
|
||||
(hiccup-tag? tag)
|
||||
(let [n (name tag)
|
||||
pos (.indexOf n ">")]
|
||||
(case pos
|
||||
-1 (native-element (cached-parse n) v 1)
|
||||
0 (let [comp (nth v 1 nil)]
|
||||
;; Support [:> comp ...]
|
||||
(assert (= ">" n) (hiccup-err v "Invalid Hiccup tag"))
|
||||
(assert (or (string? comp) (fn? comp))
|
||||
(hiccup-err v "Expected React component in"))
|
||||
(native-element #js{:name comp} v 2))
|
||||
;; Support extended hiccup syntax, i.e :div.bar>a.foo
|
||||
(recur [(subs n 0 pos)
|
||||
(assoc v 0 (subs n (inc pos)))])))
|
||||
|
||||
(instance? NativeWrapper tag)
|
||||
(native-element tag v 1)
|
||||
|
||||
:else (reag-element tag v))))
|
||||
|
||||
(declare expand-seq)
|
||||
(declare expand-seq-check)
|
||||
|
||||
(defn as-element [x]
|
||||
(cond (js-val? x) x
|
||||
(vector? x) (vec-to-elem x)
|
||||
(seq? x) (if (dev?)
|
||||
(expand-seq-check x)
|
||||
(expand-seq x))
|
||||
(named? x) (name x)
|
||||
(satisfies? IPrintWithWriter x) (pr-str x)
|
||||
:else x))
|
||||
|
||||
(set! comp/as-element as-element)
|
||||
|
||||
(defn expand-seq [s]
|
||||
(let [a (into-array s)]
|
||||
(dotimes [i (alength a)]
|
||||
(aset a i (as-element (aget a i))))
|
||||
a))
|
||||
|
||||
(defn expand-seq-dev [s o]
|
||||
(let [a (into-array s)]
|
||||
(dotimes [i (alength a)]
|
||||
(let [val (aget a i)]
|
||||
(when (and (vector? val)
|
||||
(nil? (key-from-vec val)))
|
||||
($! o :no-key true))
|
||||
(aset a i (as-element val))))
|
||||
a))
|
||||
|
||||
(defn expand-seq-check [x]
|
||||
(let [ctx #js{}
|
||||
[res derefed] (ratom/check-derefs #(expand-seq-dev x ctx))]
|
||||
(when derefed
|
||||
(warn (hiccup-err x "Reactive deref not supported in lazy seq, "
|
||||
"it should be wrapped in doall")))
|
||||
(when ($ ctx :no-key)
|
||||
(warn (hiccup-err x "Every element in a seq should have a unique :key")))
|
||||
res))
|
||||
|
||||
;; From https://github.com/babel/babel/commit/1d0e68f5a19d721fe8799b1ea331041d8bf9120e
|
||||
;; (def react-element-type (or (and (exists? js/Symbol)
|
||||
;; ($ js/Symbol :for)
|
||||
;; ($ js/Symbol for "react.element"))
|
||||
;; 60103))
|
||||
|
||||
;; (defn make-element-fast [argv comp jsprops first-child]
|
||||
;; (let [key (some-> jsprops ($ :key))
|
||||
;; ref (some-> jsprops ($ :ref))
|
||||
;; props (if (nil? jsprops) (js-obj) jsprops)]
|
||||
;; ($! props :children
|
||||
;; (case (- (count argv) first-child)
|
||||
;; 0 nil
|
||||
;; 1 (as-element (nth argv first-child))
|
||||
;; (reduce-kv (fn [a k v]
|
||||
;; (when (>= k first-child)
|
||||
;; (.push a (as-element v)))
|
||||
;; a)
|
||||
;; #js[] argv)))
|
||||
;; (js-obj "key" key
|
||||
;; "ref" ref
|
||||
;; "props" props
|
||||
;; "$$typeof" react-element-type
|
||||
;; "type" comp
|
||||
;; ;; "_store" (js-obj)
|
||||
;; )))
|
||||
|
||||
(defn make-element [argv comp jsprops first-child]
|
||||
(case (- (count argv) first-child)
|
||||
;; Optimize cases of zero or one child
|
||||
0 ($ util/react createElement comp jsprops)
|
||||
|
||||
1 ($ util/react createElement comp jsprops
|
||||
(as-element (nth argv first-child nil)))
|
||||
|
||||
(.apply ($ util/react :createElement) nil
|
||||
(reduce-kv (fn [a k v]
|
||||
(when (>= k first-child)
|
||||
(.push a (as-element v)))
|
||||
a)
|
||||
#js[comp jsprops] argv))))
|
||||
@@ -0,0 +1,596 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.impl.template');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('clojure.string');
|
||||
goog.require('clojure.walk');
|
||||
goog.require('reagent.impl.util');
|
||||
goog.require('reagent.impl.component');
|
||||
goog.require('reagent.impl.batching');
|
||||
goog.require('reagent.ratom');
|
||||
goog.require('reagent.interop');
|
||||
goog.require('reagent.debug');
|
||||
/**
|
||||
* Regular expression that parses a CSS-style id and class
|
||||
* from a tag name.
|
||||
*/
|
||||
reagent.impl.template.re_tag = /([^\s\.#]+)(?:#([^\s\.#]+))?(?:\.([^\s#]+))?/;
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
reagent.impl.template.NativeWrapper = (function (){
|
||||
});
|
||||
|
||||
reagent.impl.template.NativeWrapper.getBasis = (function (){
|
||||
return cljs.core.PersistentVector.EMPTY;
|
||||
});
|
||||
|
||||
reagent.impl.template.NativeWrapper.cljs$lang$type = true;
|
||||
|
||||
reagent.impl.template.NativeWrapper.cljs$lang$ctorStr = "reagent.impl.template/NativeWrapper";
|
||||
|
||||
reagent.impl.template.NativeWrapper.cljs$lang$ctorPrWriter = (function (this__9453__auto__,writer__9454__auto__,opt__9455__auto__){
|
||||
return cljs.core._write(writer__9454__auto__,"reagent.impl.template/NativeWrapper");
|
||||
});
|
||||
|
||||
reagent.impl.template.__GT_NativeWrapper = (function reagent$impl$template$__GT_NativeWrapper(){
|
||||
return (new reagent.impl.template.NativeWrapper());
|
||||
});
|
||||
|
||||
reagent.impl.template.named_QMARK_ = (function reagent$impl$template$named_QMARK_(x){
|
||||
return ((x instanceof cljs.core.Keyword)) || ((x instanceof cljs.core.Symbol));
|
||||
});
|
||||
reagent.impl.template.hiccup_tag_QMARK_ = (function reagent$impl$template$hiccup_tag_QMARK_(x){
|
||||
return (reagent.impl.template.named_QMARK_(x)) || (typeof x === 'string');
|
||||
});
|
||||
reagent.impl.template.valid_tag_QMARK_ = (function reagent$impl$template$valid_tag_QMARK_(x){
|
||||
return (reagent.impl.template.hiccup_tag_QMARK_(x)) || (cljs.core.ifn_QMARK_(x)) || ((x instanceof reagent.impl.template.NativeWrapper));
|
||||
});
|
||||
reagent.impl.template.prop_name_cache = ({"class": "className", "for": "htmlFor", "charset": "charSet"});
|
||||
reagent.impl.template.cache_get = (function reagent$impl$template$cache_get(o,k){
|
||||
if(o.hasOwnProperty(k)){
|
||||
return (o[k]);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.cached_prop_name = (function reagent$impl$template$cached_prop_name(k){
|
||||
if(reagent.impl.template.named_QMARK_(k)){
|
||||
var temp__5459__auto__ = reagent.impl.template.cache_get(reagent.impl.template.prop_name_cache,cljs.core.name(k));
|
||||
if((temp__5459__auto__ == null)){
|
||||
return (reagent.impl.template.prop_name_cache[cljs.core.name(k)] = reagent.impl.util.dash_to_camel(k));
|
||||
} else {
|
||||
var k_SINGLEQUOTE_ = temp__5459__auto__;
|
||||
return k_SINGLEQUOTE_;
|
||||
}
|
||||
} else {
|
||||
return k;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.js_val_QMARK_ = (function reagent$impl$template$js_val_QMARK_(x){
|
||||
return !(("object" === goog.typeOf(x)));
|
||||
});
|
||||
reagent.impl.template.kv_conv = (function reagent$impl$template$kv_conv(o,k,v){
|
||||
var G__14838 = o;
|
||||
(G__14838[reagent.impl.template.cached_prop_name(k)] = (reagent.impl.template.convert_prop_value.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.template.convert_prop_value.cljs$core$IFn$_invoke$arity$1(v) : reagent.impl.template.convert_prop_value.call(null,v)));
|
||||
|
||||
return G__14838;
|
||||
});
|
||||
reagent.impl.template.convert_prop_value = (function reagent$impl$template$convert_prop_value(x){
|
||||
if(reagent.impl.template.js_val_QMARK_(x)){
|
||||
return x;
|
||||
} else {
|
||||
if(reagent.impl.template.named_QMARK_(x)){
|
||||
return cljs.core.name(x);
|
||||
} else {
|
||||
if(cljs.core.map_QMARK_(x)){
|
||||
return cljs.core.reduce_kv(reagent.impl.template.kv_conv,({}),x);
|
||||
} else {
|
||||
if(cljs.core.coll_QMARK_(x)){
|
||||
return cljs.core.clj__GT_js(x);
|
||||
} else {
|
||||
if(cljs.core.ifn_QMARK_(x)){
|
||||
return (function() {
|
||||
var G__14839__delegate = function (args){
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(x,args);
|
||||
};
|
||||
var G__14839 = function (var_args){
|
||||
var args = null;
|
||||
if (arguments.length > 0) {
|
||||
var G__14840__i = 0, G__14840__a = new Array(arguments.length - 0);
|
||||
while (G__14840__i < G__14840__a.length) {G__14840__a[G__14840__i] = arguments[G__14840__i + 0]; ++G__14840__i;}
|
||||
args = new cljs.core.IndexedSeq(G__14840__a,0,null);
|
||||
}
|
||||
return G__14839__delegate.call(this,args);};
|
||||
G__14839.cljs$lang$maxFixedArity = 0;
|
||||
G__14839.cljs$lang$applyTo = (function (arglist__14841){
|
||||
var args = cljs.core.seq(arglist__14841);
|
||||
return G__14839__delegate(args);
|
||||
});
|
||||
G__14839.cljs$core$IFn$_invoke$arity$variadic = G__14839__delegate;
|
||||
return G__14839;
|
||||
})()
|
||||
;
|
||||
} else {
|
||||
return cljs.core.clj__GT_js(x);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
reagent.impl.template.oset = (function reagent$impl$template$oset(o,k,v){
|
||||
var G__14842 = (((o == null))?({}):o);
|
||||
(G__14842[k] = v);
|
||||
|
||||
return G__14842;
|
||||
});
|
||||
reagent.impl.template.oget = (function reagent$impl$template$oget(o,k){
|
||||
if((o == null)){
|
||||
return null;
|
||||
} else {
|
||||
return (o[k]);
|
||||
}
|
||||
});
|
||||
reagent.impl.template.set_id_class = (function reagent$impl$template$set_id_class(p,id_class){
|
||||
var id = (id_class["id"]);
|
||||
var p__$1 = (((!((id == null))) && ((reagent.impl.template.oget(p,"id") == null)))?reagent.impl.template.oset(p,"id",id):p);
|
||||
var temp__5459__auto__ = (id_class["className"]);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return p__$1;
|
||||
} else {
|
||||
var class$ = temp__5459__auto__;
|
||||
var old = reagent.impl.template.oget(p__$1,"className");
|
||||
return reagent.impl.template.oset(p__$1,"className",(((old == null))?class$:[cljs.core.str.cljs$core$IFn$_invoke$arity$1(class$)," ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(old)].join('')));
|
||||
}
|
||||
});
|
||||
reagent.impl.template.convert_props = (function reagent$impl$template$convert_props(props,id_class){
|
||||
return reagent.impl.template.set_id_class(reagent.impl.template.convert_prop_value(props),id_class);
|
||||
});
|
||||
if(typeof reagent.impl.template.find_dom_node !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.template.find_dom_node = null;
|
||||
}
|
||||
reagent.impl.template.these_inputs_have_selection_api = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, ["url",null,"tel",null,"text",null,"textarea",null,"password",null,"search",null], null), null);
|
||||
reagent.impl.template.has_selection_api_QMARK_ = (function reagent$impl$template$has_selection_api_QMARK_(input_type){
|
||||
return cljs.core.contains_QMARK_(reagent.impl.template.these_inputs_have_selection_api,input_type);
|
||||
});
|
||||
reagent.impl.template.input_set_value = (function reagent$impl$template$input_set_value(this$){
|
||||
if(cljs.core.truth_((this$["cljsInputLive"]))){
|
||||
(this$["cljsInputDirty"] = false);
|
||||
|
||||
var rendered_value = (this$["cljsRenderedValue"]);
|
||||
var dom_value = (this$["cljsDOMValue"]);
|
||||
var node = (reagent.impl.template.find_dom_node.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.template.find_dom_node.cljs$core$IFn$_invoke$arity$1(this$) : reagent.impl.template.find_dom_node.call(null,this$));
|
||||
if(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(rendered_value,dom_value)){
|
||||
if(!(((node === (document["activeElement"]))) && (reagent.impl.template.has_selection_api_QMARK_((node["type"]))) && (typeof rendered_value === 'string') && (typeof dom_value === 'string'))){
|
||||
(this$["cljsDOMValue"] = rendered_value);
|
||||
|
||||
return (node["value"] = rendered_value);
|
||||
} else {
|
||||
var node_value = (node["value"]);
|
||||
if(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(node_value,dom_value)){
|
||||
return reagent.impl.batching.do_after_render(((function (node_value,rendered_value,dom_value,node){
|
||||
return (function (){
|
||||
return (reagent.impl.template.input_set_value.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.template.input_set_value.cljs$core$IFn$_invoke$arity$1(this$) : reagent.impl.template.input_set_value.call(null,this$));
|
||||
});})(node_value,rendered_value,dom_value,node))
|
||||
);
|
||||
} else {
|
||||
var existing_offset_from_end = (cljs.core.count(node_value) - (node["selectionStart"]));
|
||||
var new_cursor_offset = (cljs.core.count(rendered_value) - existing_offset_from_end);
|
||||
(this$["cljsDOMValue"] = rendered_value);
|
||||
|
||||
(node["value"] = rendered_value);
|
||||
|
||||
(node["selectionStart"] = new_cursor_offset);
|
||||
|
||||
return (node["selectionEnd"] = new_cursor_offset);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.input_handle_change = (function reagent$impl$template$input_handle_change(this$,on_change,e){
|
||||
(this$["cljsDOMValue"] = e.target.value);
|
||||
|
||||
if(cljs.core.truth_((this$["cljsInputDirty"]))){
|
||||
} else {
|
||||
(this$["cljsInputDirty"] = true);
|
||||
|
||||
reagent.impl.batching.do_after_render((function (){
|
||||
return reagent.impl.template.input_set_value(this$);
|
||||
}));
|
||||
}
|
||||
|
||||
return (on_change.cljs$core$IFn$_invoke$arity$1 ? on_change.cljs$core$IFn$_invoke$arity$1(e) : on_change.call(null,e));
|
||||
});
|
||||
reagent.impl.template.input_render_setup = (function reagent$impl$template$input_render_setup(this$,jsprops){
|
||||
if(cljs.core.truth_((function (){var and__8770__auto__ = !((jsprops == null));
|
||||
if(and__8770__auto__){
|
||||
var and__8770__auto____$1 = jsprops.hasOwnProperty("onChange");
|
||||
if(cljs.core.truth_(and__8770__auto____$1)){
|
||||
return jsprops.hasOwnProperty("value");
|
||||
} else {
|
||||
return and__8770__auto____$1;
|
||||
}
|
||||
} else {
|
||||
return and__8770__auto__;
|
||||
}
|
||||
})())){
|
||||
if(cljs.core.truth_(reagent.impl.template.find_dom_node)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ","reagent.dom needs to be loaded for controlled input to work","\n","find-dom-node"].join('')));
|
||||
}
|
||||
|
||||
var v = (jsprops["value"]);
|
||||
var value = (((v == null))?"":v);
|
||||
var on_change = (jsprops["onChange"]);
|
||||
if(cljs.core.truth_((this$["cljsInputLive"]))){
|
||||
} else {
|
||||
(this$["cljsInputLive"] = true);
|
||||
|
||||
(this$["cljsDOMValue"] = value);
|
||||
}
|
||||
|
||||
(this$["cljsRenderedValue"] = value);
|
||||
|
||||
delete jsprops["value"];
|
||||
|
||||
var G__14844 = jsprops;
|
||||
(G__14844["defaultValue"] = value);
|
||||
|
||||
(G__14844["onChange"] = ((function (G__14844,v,value,on_change){
|
||||
return (function (p1__14843_SHARP_){
|
||||
return reagent.impl.template.input_handle_change(this$,on_change,p1__14843_SHARP_);
|
||||
});})(G__14844,v,value,on_change))
|
||||
);
|
||||
|
||||
return G__14844;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.input_unmount = (function reagent$impl$template$input_unmount(this$){
|
||||
return (this$["cljsInputLive"] = null);
|
||||
});
|
||||
reagent.impl.template.input_component_QMARK_ = (function reagent$impl$template$input_component_QMARK_(x){
|
||||
var G__14845 = x;
|
||||
switch (G__14845) {
|
||||
case "input":
|
||||
case "textarea":
|
||||
return true;
|
||||
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
|
||||
}
|
||||
});
|
||||
reagent.impl.template.reagent_input_class = null;
|
||||
reagent.impl.template.input_spec = new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$display_DASH_name,"ReagentInput",cljs.core.cst$kw$component_DASH_did_DASH_update,reagent.impl.template.input_set_value,cljs.core.cst$kw$component_DASH_will_DASH_unmount,reagent.impl.template.input_unmount,cljs.core.cst$kw$reagent_DASH_render,(function (argv,comp,jsprops,first_child){
|
||||
var this$ = reagent.impl.component._STAR_current_component_STAR_;
|
||||
reagent.impl.template.input_render_setup(this$,jsprops);
|
||||
|
||||
return (reagent.impl.template.make_element.cljs$core$IFn$_invoke$arity$4 ? reagent.impl.template.make_element.cljs$core$IFn$_invoke$arity$4(argv,comp,jsprops,first_child) : reagent.impl.template.make_element.call(null,argv,comp,jsprops,first_child));
|
||||
})], null);
|
||||
reagent.impl.template.reagent_input = (function reagent$impl$template$reagent_input(){
|
||||
if((reagent.impl.template.reagent_input_class == null)){
|
||||
reagent.impl.template.reagent_input_class = reagent.impl.component.create_class(reagent.impl.template.input_spec);
|
||||
} else {
|
||||
}
|
||||
|
||||
return reagent.impl.template.reagent_input_class;
|
||||
});
|
||||
reagent.impl.template.parse_tag = (function reagent$impl$template$parse_tag(hiccup_tag){
|
||||
var vec__14847 = cljs.core.next(cljs.core.re_matches(reagent.impl.template.re_tag,cljs.core.name(hiccup_tag)));
|
||||
var tag = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14847,(0),null);
|
||||
var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14847,(1),null);
|
||||
var class$ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14847,(2),null);
|
||||
var class$__$1 = (((class$ == null))?null:clojure.string.replace(class$,/\./," "));
|
||||
if(cljs.core.truth_(tag)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Invalid tag: '",cljs.core.str.cljs$core$IFn$_invoke$arity$1(hiccup_tag),"'",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.component.comp_name())].join('')),"\n","tag"].join('')));
|
||||
}
|
||||
|
||||
return ({"name": tag, "id": id, "className": class$__$1});
|
||||
});
|
||||
reagent.impl.template.try_get_key = (function reagent$impl$template$try_get_key(x){
|
||||
try{return cljs.core.get.cljs$core$IFn$_invoke$arity$2(x,cljs.core.cst$kw$key);
|
||||
}catch (e14850){var e = e14850;
|
||||
return null;
|
||||
}});
|
||||
reagent.impl.template.get_key = (function reagent$impl$template$get_key(x){
|
||||
if(cljs.core.map_QMARK_(x)){
|
||||
return reagent.impl.template.try_get_key(x);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.key_from_vec = (function reagent$impl$template$key_from_vec(v){
|
||||
var temp__5459__auto__ = reagent.impl.template.get_key(cljs.core.meta(v));
|
||||
if((temp__5459__auto__ == null)){
|
||||
return reagent.impl.template.get_key(cljs.core.nth.cljs$core$IFn$_invoke$arity$3(v,(1),null));
|
||||
} else {
|
||||
var k = temp__5459__auto__;
|
||||
return k;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.reag_element = (function reagent$impl$template$reag_element(tag,v){
|
||||
var c = reagent.impl.component.as_class(tag);
|
||||
var jsprops = ({"argv": v});
|
||||
var temp__5461__auto___14851 = reagent.impl.template.key_from_vec(v);
|
||||
if((temp__5461__auto___14851 == null)){
|
||||
} else {
|
||||
var key_14852 = temp__5461__auto___14851;
|
||||
(jsprops["key"] = key_14852);
|
||||
}
|
||||
|
||||
return (reagent.impl.util.react["createElement"])(c,jsprops);
|
||||
});
|
||||
reagent.impl.template.adapt_react_class = (function reagent$impl$template$adapt_react_class(c){
|
||||
var G__14853 = reagent.impl.template.__GT_NativeWrapper();
|
||||
(G__14853["name"] = c);
|
||||
|
||||
(G__14853["id"] = null);
|
||||
|
||||
(G__14853["class"] = null);
|
||||
|
||||
return G__14853;
|
||||
});
|
||||
reagent.impl.template.tag_name_cache = ({});
|
||||
reagent.impl.template.cached_parse = (function reagent$impl$template$cached_parse(x){
|
||||
var temp__5459__auto__ = reagent.impl.template.cache_get(reagent.impl.template.tag_name_cache,x);
|
||||
if((temp__5459__auto__ == null)){
|
||||
return (reagent.impl.template.tag_name_cache[x] = reagent.impl.template.parse_tag(x));
|
||||
} else {
|
||||
var s = temp__5459__auto__;
|
||||
return s;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.native_element = (function reagent$impl$template$native_element(parsed,argv,first){
|
||||
var comp = (parsed["name"]);
|
||||
var props = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(argv,first,null);
|
||||
var hasprops = ((props == null)) || (cljs.core.map_QMARK_(props));
|
||||
var jsprops = reagent.impl.template.convert_props(((hasprops)?props:null),parsed);
|
||||
var first_child = (first + ((hasprops)?(1):(0)));
|
||||
if(reagent.impl.template.input_component_QMARK_(comp)){
|
||||
var G__14854 = cljs.core.with_meta(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [reagent.impl.template.reagent_input(),argv,comp,jsprops,first_child], null),cljs.core.meta(argv));
|
||||
return (reagent.impl.template.as_element.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.template.as_element.cljs$core$IFn$_invoke$arity$1(G__14854) : reagent.impl.template.as_element.call(null,G__14854));
|
||||
} else {
|
||||
var key = reagent.impl.template.get_key(cljs.core.meta(argv));
|
||||
var p = (((key == null))?jsprops:reagent.impl.template.oset(jsprops,"key",key));
|
||||
return (reagent.impl.template.make_element.cljs$core$IFn$_invoke$arity$4 ? reagent.impl.template.make_element.cljs$core$IFn$_invoke$arity$4(argv,comp,p,first_child) : reagent.impl.template.make_element.call(null,argv,comp,p,first_child));
|
||||
}
|
||||
});
|
||||
reagent.impl.template.str_coll = (function reagent$impl$template$str_coll(coll){
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(clojure.walk.prewalk((function (x){
|
||||
if(cljs.core.fn_QMARK_(x)){
|
||||
var n = reagent.impl.util.fun_name(x);
|
||||
var G__14855 = n;
|
||||
switch (G__14855) {
|
||||
case "":
|
||||
return x;
|
||||
|
||||
break;
|
||||
default:
|
||||
return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(n);
|
||||
|
||||
}
|
||||
} else {
|
||||
return x;
|
||||
}
|
||||
}),coll))].join('');
|
||||
|
||||
});
|
||||
reagent.impl.template.hiccup_err = (function reagent$impl$template$hiccup_err(var_args){
|
||||
var args__10068__auto__ = [];
|
||||
var len__10061__auto___14859 = arguments.length;
|
||||
var i__10062__auto___14860 = (0);
|
||||
while(true){
|
||||
if((i__10062__auto___14860 < len__10061__auto___14859)){
|
||||
args__10068__auto__.push((arguments[i__10062__auto___14860]));
|
||||
|
||||
var G__14861 = (i__10062__auto___14860 + (1));
|
||||
i__10062__auto___14860 = G__14861;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
var argseq__10069__auto__ = ((((1) < args__10068__auto__.length))?(new cljs.core.IndexedSeq(args__10068__auto__.slice((1)),(0),null)):null);
|
||||
return reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__10069__auto__);
|
||||
});
|
||||
|
||||
reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic = (function (v,msg){
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,msg)),": ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.str_coll(v)),"\n",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.component.comp_name())].join('');
|
||||
});
|
||||
|
||||
reagent.impl.template.hiccup_err.cljs$lang$maxFixedArity = (1);
|
||||
|
||||
reagent.impl.template.hiccup_err.cljs$lang$applyTo = (function (seq14857){
|
||||
var G__14858 = cljs.core.first(seq14857);
|
||||
var seq14857__$1 = cljs.core.next(seq14857);
|
||||
return reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(G__14858,seq14857__$1);
|
||||
});
|
||||
|
||||
reagent.impl.template.vec_to_elem = (function reagent$impl$template$vec_to_elem(v){
|
||||
while(true){
|
||||
if((cljs.core.count(v) > (0))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(v,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Hiccup form should not be empty"], 0))),"\n","(pos? (count v))"].join('')));
|
||||
}
|
||||
|
||||
var tag = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(v,(0),null);
|
||||
if(reagent.impl.template.valid_tag_QMARK_(tag)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(v,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid Hiccup form"], 0))),"\n","(valid-tag? tag)"].join('')));
|
||||
}
|
||||
|
||||
if(reagent.impl.template.hiccup_tag_QMARK_(tag)){
|
||||
var n = cljs.core.name(tag);
|
||||
var pos = n.indexOf(">");
|
||||
var G__14862 = pos;
|
||||
switch (G__14862) {
|
||||
case (-1):
|
||||
return reagent.impl.template.native_element(reagent.impl.template.cached_parse(n),v,(1));
|
||||
|
||||
break;
|
||||
case (0):
|
||||
var comp = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(v,(1),null);
|
||||
if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(">",n)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(v,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid Hiccup tag"], 0))),"\n","(= \">\" n)"].join('')));
|
||||
}
|
||||
|
||||
if((typeof comp === 'string') || (cljs.core.fn_QMARK_(comp))){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(v,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Expected React component in"], 0))),"\n","(or (string? comp) (fn? comp))"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.template.native_element(({"name": comp}),v,(2));
|
||||
|
||||
break;
|
||||
default:
|
||||
var G__14864 = new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.subs.cljs$core$IFn$_invoke$arity$3(n,(0),pos),cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(v,(0),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(n,(pos + (1))))], null);
|
||||
v = G__14864;
|
||||
continue;
|
||||
|
||||
}
|
||||
} else {
|
||||
if((tag instanceof reagent.impl.template.NativeWrapper)){
|
||||
return reagent.impl.template.native_element(tag,v,(1));
|
||||
} else {
|
||||
return reagent.impl.template.reag_element(tag,v);
|
||||
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
reagent.impl.template.as_element = (function reagent$impl$template$as_element(x){
|
||||
if(reagent.impl.template.js_val_QMARK_(x)){
|
||||
return x;
|
||||
} else {
|
||||
if(cljs.core.vector_QMARK_(x)){
|
||||
return reagent.impl.template.vec_to_elem(x);
|
||||
} else {
|
||||
if(cljs.core.seq_QMARK_(x)){
|
||||
return (reagent.impl.template.expand_seq_check.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.template.expand_seq_check.cljs$core$IFn$_invoke$arity$1(x) : reagent.impl.template.expand_seq_check.call(null,x));
|
||||
|
||||
} else {
|
||||
if(reagent.impl.template.named_QMARK_(x)){
|
||||
return cljs.core.name(x);
|
||||
} else {
|
||||
if(((!((x == null)))?((((x.cljs$lang$protocol_mask$partition0$ & (2147483648))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IPrintWithWriter$)))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,x))){
|
||||
return cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([x], 0));
|
||||
} else {
|
||||
return x;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
reagent.impl.component.as_element = reagent.impl.template.as_element;
|
||||
reagent.impl.template.expand_seq = (function reagent$impl$template$expand_seq(s){
|
||||
var a = cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(s);
|
||||
var n__9827__auto___14866 = a.length;
|
||||
var i_14867 = (0);
|
||||
while(true){
|
||||
if((i_14867 < n__9827__auto___14866)){
|
||||
(a[i_14867] = reagent.impl.template.as_element((a[i_14867])));
|
||||
|
||||
var G__14868 = (i_14867 + (1));
|
||||
i_14867 = G__14868;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return a;
|
||||
});
|
||||
reagent.impl.template.expand_seq_dev = (function reagent$impl$template$expand_seq_dev(s,o){
|
||||
var a = cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(s);
|
||||
var n__9827__auto___14869 = a.length;
|
||||
var i_14870 = (0);
|
||||
while(true){
|
||||
if((i_14870 < n__9827__auto___14869)){
|
||||
var val_14871 = (a[i_14870]);
|
||||
if((cljs.core.vector_QMARK_(val_14871)) && ((reagent.impl.template.key_from_vec(val_14871) == null))){
|
||||
(o["no-key"] = true);
|
||||
} else {
|
||||
}
|
||||
|
||||
(a[i_14870] = reagent.impl.template.as_element(val_14871));
|
||||
|
||||
var G__14872 = (i_14870 + (1));
|
||||
i_14870 = G__14872;
|
||||
continue;
|
||||
} else {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return a;
|
||||
});
|
||||
reagent.impl.template.expand_seq_check = (function reagent$impl$template$expand_seq_check(x){
|
||||
var ctx = ({});
|
||||
var vec__14873 = reagent.ratom.check_derefs(((function (ctx){
|
||||
return (function (){
|
||||
return reagent.impl.template.expand_seq_dev(x,ctx);
|
||||
});})(ctx))
|
||||
);
|
||||
var res = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14873,(0),null);
|
||||
var derefed = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14873,(1),null);
|
||||
if(cljs.core.truth_(derefed)){
|
||||
if(cljs.core.truth_(reagent.debug.has_console)){
|
||||
(cljs.core.truth_(reagent.debug.tracking)?reagent.debug.track_console:console).warn(["Warning: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Reactive deref not supported in lazy seq, ","it should be wrapped in doall"], 0)))].join(''));
|
||||
} else {
|
||||
}
|
||||
} else {
|
||||
}
|
||||
|
||||
if(cljs.core.truth_((ctx["no-key"]))){
|
||||
if(cljs.core.truth_(reagent.debug.has_console)){
|
||||
(cljs.core.truth_(reagent.debug.tracking)?reagent.debug.track_console:console).warn(["Warning: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(reagent.impl.template.hiccup_err.cljs$core$IFn$_invoke$arity$variadic(x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Every element in a seq should have a unique :key"], 0)))].join(''));
|
||||
} else {
|
||||
}
|
||||
} else {
|
||||
}
|
||||
|
||||
return res;
|
||||
});
|
||||
reagent.impl.template.make_element = (function reagent$impl$template$make_element(argv,comp,jsprops,first_child){
|
||||
var G__14876 = (cljs.core.count(argv) - first_child);
|
||||
switch (G__14876) {
|
||||
case (0):
|
||||
return (reagent.impl.util.react["createElement"])(comp,jsprops);
|
||||
|
||||
break;
|
||||
case (1):
|
||||
return (reagent.impl.util.react["createElement"])(comp,jsprops,reagent.impl.template.as_element(cljs.core.nth.cljs$core$IFn$_invoke$arity$3(argv,first_child,null)));
|
||||
|
||||
break;
|
||||
default:
|
||||
return (reagent.impl.util.react["createElement"]).apply(null,cljs.core.reduce_kv(((function (G__14876){
|
||||
return (function (a,k,v){
|
||||
if((k >= first_child)){
|
||||
a.push(reagent.impl.template.as_element(v));
|
||||
} else {
|
||||
}
|
||||
|
||||
return a;
|
||||
});})(G__14876))
|
||||
,[comp,jsprops],argv));
|
||||
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,155 @@
|
||||
(ns reagent.impl.util
|
||||
(:require [cljsjs.react]
|
||||
[cljsjs.create-react-class]
|
||||
[reagent.debug :refer-macros [dbg log warn]]
|
||||
[reagent.interop :refer-macros [$ $!]]
|
||||
[clojure.string :as string]))
|
||||
|
||||
(defonce react
|
||||
(cond (exists? js/React) js/React
|
||||
(exists? js/require) (or (js/require "react")
|
||||
(throw (js/Error. "require('react') failed")))
|
||||
:else (throw (js/Error. "js/React is missing"))))
|
||||
|
||||
(defonce create-class
|
||||
(cond (exists? js/createReactClass) js/createReactClass
|
||||
(exists? js/require) (or (js/require "create-react-class")
|
||||
(throw (js/Error. "require('create-react-class') failed")))
|
||||
:else (throw (js/Error. "js/createReactClass is missing"))))
|
||||
|
||||
(def is-client (and (exists? js/window)
|
||||
(-> js/window ($ :document) nil? not)))
|
||||
|
||||
(def ^:dynamic ^boolean *non-reactive* false)
|
||||
|
||||
;;; Props accessors
|
||||
|
||||
;; Misc utilities
|
||||
|
||||
(defn memoize-1 [f]
|
||||
(let [mem (atom {})]
|
||||
(fn [arg]
|
||||
(let [v (get @mem arg)]
|
||||
(if-not (nil? v)
|
||||
v
|
||||
(let [ret (f arg)]
|
||||
(swap! mem assoc arg ret)
|
||||
ret))))))
|
||||
|
||||
(def dont-camel-case #{"aria" "data"})
|
||||
|
||||
(defn capitalize [s]
|
||||
(if (< (count s) 2)
|
||||
(string/upper-case s)
|
||||
(str (string/upper-case (subs s 0 1)) (subs s 1))))
|
||||
|
||||
(defn dash-to-camel [dashed]
|
||||
(if (string? dashed)
|
||||
dashed
|
||||
(let [name-str (name dashed)
|
||||
[start & parts] (string/split name-str #"-")]
|
||||
(if (dont-camel-case start)
|
||||
name-str
|
||||
(apply str start (map capitalize parts))))))
|
||||
|
||||
(defn fun-name [f]
|
||||
(let [n (or (and (fn? f)
|
||||
(or ($ f :displayName)
|
||||
($ f :name)))
|
||||
(and (implements? INamed f)
|
||||
(name f))
|
||||
(let [m (meta f)]
|
||||
(if (map? m)
|
||||
(:name m))))]
|
||||
(-> n
|
||||
str
|
||||
(clojure.string/replace "$" "."))))
|
||||
|
||||
(deftype PartialFn [pfn f args]
|
||||
Fn
|
||||
IFn
|
||||
(-invoke [_]
|
||||
(pfn))
|
||||
(-invoke [_ a]
|
||||
(pfn a))
|
||||
(-invoke [_ a b]
|
||||
(pfn a b))
|
||||
(-invoke [_ a b c]
|
||||
(pfn a b c))
|
||||
(-invoke [_ a b c d]
|
||||
(pfn a b c d))
|
||||
(-invoke [_ a b c d e]
|
||||
(pfn a b c d e))
|
||||
(-invoke [_ a b c d e f]
|
||||
(pfn a b c d e f))
|
||||
(-invoke [_ a b c d e f g]
|
||||
(pfn a b c d e f g))
|
||||
(-invoke [_ a b c d e f g h]
|
||||
(pfn a b c d e f g h))
|
||||
(-invoke [_ a b c d e f g h i]
|
||||
(pfn a b c d e f g h i))
|
||||
(-invoke [_ a b c d e f g h i j]
|
||||
(pfn a b c d e f g h i j))
|
||||
(-invoke [_ a b c d e f g h i j k]
|
||||
(pfn a b c d e f g h i j k))
|
||||
(-invoke [_ a b c d e f g h i j k l]
|
||||
(pfn a b c d e f g h i j k l))
|
||||
(-invoke [_ a b c d e f g h i j k l m]
|
||||
(pfn a b c d e f g h i j k l m))
|
||||
(-invoke [_ a b c d e f g h i j k l m n]
|
||||
(pfn a b c d e f g h i j k l m n))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o]
|
||||
(pfn a b c d e f g h i j k l m n o))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p]
|
||||
(pfn a b c d e f g h i j k l m n o p))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p q]
|
||||
(pfn a b c d e f g h i j k l m n o p q))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p q r]
|
||||
(pfn a b c d e f g h i j k l m n o p q r))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p q r s]
|
||||
(pfn a b c d e f g h i j k l m n o p q r s))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p q r s t]
|
||||
(pfn a b c d e f g h i j k l m n o p q r s t))
|
||||
(-invoke [_ a b c d e f g h i j k l m n o p q r s t rest]
|
||||
(apply pfn a b c d e f g h i j k l m n o p q r s t rest))
|
||||
IEquiv
|
||||
(-equiv [_ other]
|
||||
(and (= f (.-f other)) (= args (.-args other))))
|
||||
IHash
|
||||
(-hash [_] (hash [f args])))
|
||||
|
||||
(defn make-partial-fn [f args]
|
||||
(->PartialFn (apply partial f args) f args))
|
||||
|
||||
(defn- merge-class [p1 p2]
|
||||
(let [class (when-let [c1 (:class p1)]
|
||||
(when-let [c2 (:class p2)]
|
||||
(str c1 " " c2)))]
|
||||
(if (nil? class)
|
||||
p2
|
||||
(assoc p2 :class class))))
|
||||
|
||||
(defn- merge-style [p1 p2]
|
||||
(let [style (when-let [s1 (:style p1)]
|
||||
(when-let [s2 (:style p2)]
|
||||
(merge s1 s2)))]
|
||||
(if (nil? style)
|
||||
p2
|
||||
(assoc p2 :style style))))
|
||||
|
||||
(defn merge-props [p1 p2]
|
||||
(if (nil? p1)
|
||||
p2
|
||||
(do
|
||||
(assert (map? p1)
|
||||
(str "Property must be a map, not " (pr-str p1)))
|
||||
(merge-style p1 (merge-class p1 (merge p1 p2))))))
|
||||
|
||||
|
||||
(def ^:dynamic *always-update* false)
|
||||
|
||||
(defn force-update [comp deep]
|
||||
(if deep
|
||||
(binding [*always-update* true]
|
||||
($ comp forceUpdate))
|
||||
($ comp forceUpdate)))
|
||||
@@ -0,0 +1,571 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.impl.util');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
goog.require('reagent.debug');
|
||||
goog.require('reagent.interop');
|
||||
goog.require('clojure.string');
|
||||
if(typeof reagent.impl.util.react !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.util.react = ((typeof React !== 'undefined')?React:((typeof require !== 'undefined')?(function (){var or__8782__auto__ = require("react");
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
throw (new Error("require('react') failed"));
|
||||
}
|
||||
})():(function(){throw (new Error("js/React is missing"))})()
|
||||
));
|
||||
}
|
||||
if(typeof reagent.impl.util.create_class !== 'undefined'){
|
||||
} else {
|
||||
reagent.impl.util.create_class = ((typeof createReactClass !== 'undefined')?createReactClass:((typeof require !== 'undefined')?(function (){var or__8782__auto__ = require("create-react-class");
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
throw (new Error("require('create-react-class') failed"));
|
||||
}
|
||||
})():(function(){throw (new Error("js/createReactClass is missing"))})()
|
||||
));
|
||||
}
|
||||
reagent.impl.util.is_client = (typeof window !== 'undefined') && (!(((window["document"]) == null)));
|
||||
reagent.impl.util._STAR_non_reactive_STAR_ = false;
|
||||
reagent.impl.util.memoize_1 = (function reagent$impl$util$memoize_1(f){
|
||||
var mem = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);
|
||||
return ((function (mem){
|
||||
return (function (arg){
|
||||
var v = cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(mem),arg);
|
||||
if(!((v == null))){
|
||||
return v;
|
||||
} else {
|
||||
var ret = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(arg) : f.call(null,arg));
|
||||
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(mem,cljs.core.assoc,arg,ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
});
|
||||
;})(mem))
|
||||
});
|
||||
reagent.impl.util.dont_camel_case = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, ["aria",null,"data",null], null), null);
|
||||
reagent.impl.util.capitalize = (function reagent$impl$util$capitalize(s){
|
||||
if((cljs.core.count(s) < (2))){
|
||||
return clojure.string.upper_case(s);
|
||||
} else {
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(clojure.string.upper_case(cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),(1)))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(1)))].join('');
|
||||
}
|
||||
});
|
||||
reagent.impl.util.dash_to_camel = (function reagent$impl$util$dash_to_camel(dashed){
|
||||
if(typeof dashed === 'string'){
|
||||
return dashed;
|
||||
} else {
|
||||
var name_str = cljs.core.name(dashed);
|
||||
var vec__14526 = clojure.string.split.cljs$core$IFn$_invoke$arity$2(name_str,/-/);
|
||||
var seq__14527 = cljs.core.seq(vec__14526);
|
||||
var first__14528 = cljs.core.first(seq__14527);
|
||||
var seq__14527__$1 = cljs.core.next(seq__14527);
|
||||
var start = first__14528;
|
||||
var parts = seq__14527__$1;
|
||||
if(cljs.core.truth_((reagent.impl.util.dont_camel_case.cljs$core$IFn$_invoke$arity$1 ? reagent.impl.util.dont_camel_case.cljs$core$IFn$_invoke$arity$1(start) : reagent.impl.util.dont_camel_case.call(null,start)))){
|
||||
return name_str;
|
||||
} else {
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.str,start,cljs.core.map.cljs$core$IFn$_invoke$arity$2(reagent.impl.util.capitalize,parts));
|
||||
}
|
||||
}
|
||||
});
|
||||
reagent.impl.util.fun_name = (function reagent$impl$util$fun_name(f){
|
||||
var n = (function (){var or__8782__auto__ = (function (){var and__8770__auto__ = cljs.core.fn_QMARK_(f);
|
||||
if(and__8770__auto__){
|
||||
var or__8782__auto__ = (f["displayName"]);
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
return (f["name"]);
|
||||
}
|
||||
} else {
|
||||
return and__8770__auto__;
|
||||
}
|
||||
})();
|
||||
if(cljs.core.truth_(or__8782__auto__)){
|
||||
return or__8782__auto__;
|
||||
} else {
|
||||
var or__8782__auto____$1 = (function (){var and__8770__auto__ = ((!((f == null)))?((((f.cljs$lang$protocol_mask$partition1$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === f.cljs$core$INamed$)))?true:false):false);
|
||||
if(and__8770__auto__){
|
||||
return cljs.core.name(f);
|
||||
} else {
|
||||
return and__8770__auto__;
|
||||
}
|
||||
})();
|
||||
if(cljs.core.truth_(or__8782__auto____$1)){
|
||||
return or__8782__auto____$1;
|
||||
} else {
|
||||
var m = cljs.core.meta(f);
|
||||
if(cljs.core.map_QMARK_(m)){
|
||||
return cljs.core.cst$kw$name.cljs$core$IFn$_invoke$arity$1(m);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
})();
|
||||
return clojure.string.replace([cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)].join(''),"$",".");
|
||||
});
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @implements {cljs.core.IEquiv}
|
||||
* @implements {cljs.core.IHash}
|
||||
* @implements {cljs.core.IFn}
|
||||
* @implements {cljs.core.Fn}
|
||||
*/
|
||||
reagent.impl.util.PartialFn = (function (pfn,f,args){
|
||||
this.pfn = pfn;
|
||||
this.f = f;
|
||||
this.args = args;
|
||||
this.cljs$lang$protocol_mask$partition0$ = 6291457;
|
||||
this.cljs$lang$protocol_mask$partition1$ = 0;
|
||||
});
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$Fn$ = cljs.core.PROTOCOL_SENTINEL;
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.call = (function() {
|
||||
var G__14534 = null;
|
||||
var G__14534__1 = (function (self__){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$0 ? self__.pfn.cljs$core$IFn$_invoke$arity$0() : self__.pfn.call(null));
|
||||
});
|
||||
var G__14534__2 = (function (self__,a){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$1 ? self__.pfn.cljs$core$IFn$_invoke$arity$1(a) : self__.pfn.call(null,a));
|
||||
});
|
||||
var G__14534__3 = (function (self__,a,b){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$2 ? self__.pfn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.pfn.call(null,a,b));
|
||||
});
|
||||
var G__14534__4 = (function (self__,a,b,c){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$3 ? self__.pfn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.pfn.call(null,a,b,c));
|
||||
});
|
||||
var G__14534__5 = (function (self__,a,b,c,d){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$4 ? self__.pfn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.pfn.call(null,a,b,c,d));
|
||||
});
|
||||
var G__14534__6 = (function (self__,a,b,c,d,e){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$5 ? self__.pfn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.pfn.call(null,a,b,c,d,e));
|
||||
});
|
||||
var G__14534__7 = (function (self__,a,b,c,d,e,f__$1){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$6 ? self__.pfn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f__$1) : self__.pfn.call(null,a,b,c,d,e,f__$1));
|
||||
});
|
||||
var G__14534__8 = (function (self__,a,b,c,d,e,f__$1,g){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$7 ? self__.pfn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f__$1,g) : self__.pfn.call(null,a,b,c,d,e,f__$1,g));
|
||||
});
|
||||
var G__14534__9 = (function (self__,a,b,c,d,e,f__$1,g,h){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$8 ? self__.pfn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f__$1,g,h) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h));
|
||||
});
|
||||
var G__14534__10 = (function (self__,a,b,c,d,e,f__$1,g,h,i){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$9 ? self__.pfn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f__$1,g,h,i) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i));
|
||||
});
|
||||
var G__14534__11 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$10 ? self__.pfn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f__$1,g,h,i,j) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j));
|
||||
});
|
||||
var G__14534__12 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$11 ? self__.pfn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f__$1,g,h,i,j,k) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k));
|
||||
});
|
||||
var G__14534__13 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$12 ? self__.pfn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f__$1,g,h,i,j,k,l) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l));
|
||||
});
|
||||
var G__14534__14 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$13 ? self__.pfn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f__$1,g,h,i,j,k,l,m) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m));
|
||||
});
|
||||
var G__14534__15 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$14 ? self__.pfn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n));
|
||||
});
|
||||
var G__14534__16 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$15 ? self__.pfn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o));
|
||||
});
|
||||
var G__14534__17 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$16 ? self__.pfn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p));
|
||||
});
|
||||
var G__14534__18 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$17 ? self__.pfn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q));
|
||||
});
|
||||
var G__14534__19 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$18 ? self__.pfn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r));
|
||||
});
|
||||
var G__14534__20 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$19 ? self__.pfn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s));
|
||||
});
|
||||
var G__14534__21 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$20 ? self__.pfn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t));
|
||||
});
|
||||
var G__14534__22 = (function (self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
var _ = self____$1;
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.pfn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0));
|
||||
});
|
||||
G__14534 = function(self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){
|
||||
switch(arguments.length){
|
||||
case 1:
|
||||
return G__14534__1.call(this,self__);
|
||||
case 2:
|
||||
return G__14534__2.call(this,self__,a);
|
||||
case 3:
|
||||
return G__14534__3.call(this,self__,a,b);
|
||||
case 4:
|
||||
return G__14534__4.call(this,self__,a,b,c);
|
||||
case 5:
|
||||
return G__14534__5.call(this,self__,a,b,c,d);
|
||||
case 6:
|
||||
return G__14534__6.call(this,self__,a,b,c,d,e);
|
||||
case 7:
|
||||
return G__14534__7.call(this,self__,a,b,c,d,e,f__$1);
|
||||
case 8:
|
||||
return G__14534__8.call(this,self__,a,b,c,d,e,f__$1,g);
|
||||
case 9:
|
||||
return G__14534__9.call(this,self__,a,b,c,d,e,f__$1,g,h);
|
||||
case 10:
|
||||
return G__14534__10.call(this,self__,a,b,c,d,e,f__$1,g,h,i);
|
||||
case 11:
|
||||
return G__14534__11.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j);
|
||||
case 12:
|
||||
return G__14534__12.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k);
|
||||
case 13:
|
||||
return G__14534__13.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l);
|
||||
case 14:
|
||||
return G__14534__14.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m);
|
||||
case 15:
|
||||
return G__14534__15.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n);
|
||||
case 16:
|
||||
return G__14534__16.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o);
|
||||
case 17:
|
||||
return G__14534__17.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p);
|
||||
case 18:
|
||||
return G__14534__18.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q);
|
||||
case 19:
|
||||
return G__14534__19.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r);
|
||||
case 20:
|
||||
return G__14534__20.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s);
|
||||
case 21:
|
||||
return G__14534__21.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t);
|
||||
case 22:
|
||||
return G__14534__22.call(this,self__,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest);
|
||||
}
|
||||
throw(new Error('Invalid arity: ' + (arguments.length - 1)));
|
||||
};
|
||||
G__14534.cljs$core$IFn$_invoke$arity$1 = G__14534__1;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$2 = G__14534__2;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$3 = G__14534__3;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$4 = G__14534__4;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$5 = G__14534__5;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$6 = G__14534__6;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$7 = G__14534__7;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$8 = G__14534__8;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$9 = G__14534__9;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$10 = G__14534__10;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$11 = G__14534__11;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$12 = G__14534__12;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$13 = G__14534__13;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$14 = G__14534__14;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$15 = G__14534__15;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$16 = G__14534__16;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$17 = G__14534__17;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$18 = G__14534__18;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$19 = G__14534__19;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$20 = G__14534__20;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$21 = G__14534__21;
|
||||
G__14534.cljs$core$IFn$_invoke$arity$22 = G__14534__22;
|
||||
return G__14534;
|
||||
})()
|
||||
;
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.apply = (function (self__,args14533){
|
||||
var self__ = this;
|
||||
var self____$1 = this;
|
||||
return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args14533)));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$0 = (function (){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$0 ? self__.pfn.cljs$core$IFn$_invoke$arity$0() : self__.pfn.call(null));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$1 = (function (a){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$1 ? self__.pfn.cljs$core$IFn$_invoke$arity$1(a) : self__.pfn.call(null,a));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$2 ? self__.pfn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.pfn.call(null,a,b));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$3 = (function (a,b,c){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$3 ? self__.pfn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.pfn.call(null,a,b,c));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$4 = (function (a,b,c,d){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$4 ? self__.pfn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.pfn.call(null,a,b,c,d));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$5 = (function (a,b,c,d,e){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$5 ? self__.pfn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.pfn.call(null,a,b,c,d,e));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$6 = (function (a,b,c,d,e,f__$1){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$6 ? self__.pfn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f__$1) : self__.pfn.call(null,a,b,c,d,e,f__$1));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$7 = (function (a,b,c,d,e,f__$1,g){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$7 ? self__.pfn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f__$1,g) : self__.pfn.call(null,a,b,c,d,e,f__$1,g));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$8 = (function (a,b,c,d,e,f__$1,g,h){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$8 ? self__.pfn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f__$1,g,h) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$9 = (function (a,b,c,d,e,f__$1,g,h,i){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$9 ? self__.pfn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f__$1,g,h,i) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$10 = (function (a,b,c,d,e,f__$1,g,h,i,j){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$10 ? self__.pfn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f__$1,g,h,i,j) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$11 = (function (a,b,c,d,e,f__$1,g,h,i,j,k){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$11 ? self__.pfn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f__$1,g,h,i,j,k) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$12 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$12 ? self__.pfn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f__$1,g,h,i,j,k,l) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$13 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$13 ? self__.pfn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f__$1,g,h,i,j,k,l,m) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$14 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$14 ? self__.pfn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$15 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$15 ? self__.pfn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$16 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$16 ? self__.pfn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$17 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$17 ? self__.pfn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$18 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$18 ? self__.pfn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$19 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$19 ? self__.pfn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$20 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return (self__.pfn.cljs$core$IFn$_invoke$arity$20 ? self__.pfn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.pfn.call(null,a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IFn$_invoke$arity$21 = (function (a,b,c,d,e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){
|
||||
var self__ = this;
|
||||
var _ = this;
|
||||
return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.pfn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f__$1,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (_,other){
|
||||
var self__ = this;
|
||||
var ___$1 = this;
|
||||
return (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.f,other.f)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.args,other.args));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.prototype.cljs$core$IHash$_hash$arity$1 = (function (_){
|
||||
var self__ = this;
|
||||
var ___$1 = this;
|
||||
return cljs.core.hash(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.f,self__.args], null));
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.getBasis = (function (){
|
||||
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$pfn,cljs.core.cst$sym$f,cljs.core.cst$sym$args], null);
|
||||
});
|
||||
|
||||
reagent.impl.util.PartialFn.cljs$lang$type = true;
|
||||
|
||||
reagent.impl.util.PartialFn.cljs$lang$ctorStr = "reagent.impl.util/PartialFn";
|
||||
|
||||
reagent.impl.util.PartialFn.cljs$lang$ctorPrWriter = (function (this__9453__auto__,writer__9454__auto__,opt__9455__auto__){
|
||||
return cljs.core._write(writer__9454__auto__,"reagent.impl.util/PartialFn");
|
||||
});
|
||||
|
||||
reagent.impl.util.__GT_PartialFn = (function reagent$impl$util$__GT_PartialFn(pfn,f,args){
|
||||
return (new reagent.impl.util.PartialFn(pfn,f,args));
|
||||
});
|
||||
|
||||
reagent.impl.util.make_partial_fn = (function reagent$impl$util$make_partial_fn(f,args){
|
||||
return reagent.impl.util.__GT_PartialFn(cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.partial,f,args),f,args);
|
||||
});
|
||||
reagent.impl.util.merge_class = (function reagent$impl$util$merge_class(p1,p2){
|
||||
var class$ = (function (){var temp__5457__auto__ = cljs.core.cst$kw$class.cljs$core$IFn$_invoke$arity$1(p1);
|
||||
if(cljs.core.truth_(temp__5457__auto__)){
|
||||
var c1 = temp__5457__auto__;
|
||||
var temp__5457__auto____$1 = cljs.core.cst$kw$class.cljs$core$IFn$_invoke$arity$1(p2);
|
||||
if(cljs.core.truth_(temp__5457__auto____$1)){
|
||||
var c2 = temp__5457__auto____$1;
|
||||
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(c1)," ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(c2)].join('');
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
})();
|
||||
if((class$ == null)){
|
||||
return p2;
|
||||
} else {
|
||||
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(p2,cljs.core.cst$kw$class,class$);
|
||||
}
|
||||
});
|
||||
reagent.impl.util.merge_style = (function reagent$impl$util$merge_style(p1,p2){
|
||||
var style = (function (){var temp__5457__auto__ = cljs.core.cst$kw$style.cljs$core$IFn$_invoke$arity$1(p1);
|
||||
if(cljs.core.truth_(temp__5457__auto__)){
|
||||
var s1 = temp__5457__auto__;
|
||||
var temp__5457__auto____$1 = cljs.core.cst$kw$style.cljs$core$IFn$_invoke$arity$1(p2);
|
||||
if(cljs.core.truth_(temp__5457__auto____$1)){
|
||||
var s2 = temp__5457__auto____$1;
|
||||
return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([s1,s2], 0));
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
})();
|
||||
if((style == null)){
|
||||
return p2;
|
||||
} else {
|
||||
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(p2,cljs.core.cst$kw$style,style);
|
||||
}
|
||||
});
|
||||
reagent.impl.util.merge_props = (function reagent$impl$util$merge_props(p1,p2){
|
||||
if((p1 == null)){
|
||||
return p2;
|
||||
} else {
|
||||
if(cljs.core.map_QMARK_(p1)){
|
||||
} else {
|
||||
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["Property must be a map, not ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([p1], 0)))].join('')),"\n","(map? p1)"].join('')));
|
||||
}
|
||||
|
||||
return reagent.impl.util.merge_style(p1,reagent.impl.util.merge_class(p1,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([p1,p2], 0))));
|
||||
}
|
||||
});
|
||||
reagent.impl.util._STAR_always_update_STAR_ = false;
|
||||
reagent.impl.util.force_update = (function reagent$impl$util$force_update(comp,deep){
|
||||
if(cljs.core.truth_(deep)){
|
||||
var _STAR_always_update_STAR_14535 = reagent.impl.util._STAR_always_update_STAR_;
|
||||
reagent.impl.util._STAR_always_update_STAR_ = true;
|
||||
|
||||
try{return (comp["forceUpdate"])();
|
||||
}finally {reagent.impl.util._STAR_always_update_STAR_ = _STAR_always_update_STAR_14535;
|
||||
}} else {
|
||||
return (comp["forceUpdate"])();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,2 @@
|
||||
(ns reagent.interop
|
||||
(:require-macros [reagent.interop]))
|
||||
@@ -0,0 +1,4 @@
|
||||
// Compiled by ClojureScript 1.9.946 {:static-fns true, :optimize-constants true}
|
||||
goog.provide('reagent.interop');
|
||||
goog.require('cljs.core');
|
||||
goog.require('cljs.core.constants');
|
||||
@@ -0,0 +1,592 @@
|
||||
(ns reagent.ratom
|
||||
(:refer-clojure :exclude [atom])
|
||||
(:require-macros [reagent.ratom :refer [with-let]])
|
||||
(:require [reagent.impl.util :as util]
|
||||
[reagent.debug :refer-macros [dbg log warn error dev? time]]
|
||||
[reagent.impl.batching :as batch]
|
||||
[clojure.set :as s]))
|
||||
|
||||
(declare ^:dynamic *ratom-context*)
|
||||
(defonce ^boolean debug false)
|
||||
(defonce ^:private generation 0)
|
||||
(defonce ^:private -running (clojure.core/atom 0))
|
||||
|
||||
(defn ^boolean reactive? []
|
||||
(some? *ratom-context*))
|
||||
|
||||
|
||||
;;; Utilities
|
||||
|
||||
(defn running []
|
||||
(+ @-running))
|
||||
|
||||
(defn- ^number arr-len [x]
|
||||
(if (nil? x) 0 (alength x)))
|
||||
|
||||
(defn- ^boolean arr-eq [x y]
|
||||
(let [len (arr-len x)]
|
||||
(and (== len (arr-len y))
|
||||
(loop [i 0]
|
||||
(or (== i len)
|
||||
(if (identical? (aget x i) (aget y i))
|
||||
(recur (inc i))
|
||||
false))))))
|
||||
|
||||
(defn- in-context [obj f]
|
||||
(binding [*ratom-context* obj]
|
||||
(f)))
|
||||
|
||||
(defn- deref-capture [f r]
|
||||
(set! (.-captured r) nil)
|
||||
(when (dev?)
|
||||
(set! (.-ratomGeneration r) (set! generation (inc generation))))
|
||||
(let [res (in-context r f)
|
||||
c (.-captured r)]
|
||||
(set! (.-dirty? r) false)
|
||||
;; Optimize common case where derefs occur in same order
|
||||
(when-not (arr-eq c (.-watching r))
|
||||
(._update-watching r c))
|
||||
res))
|
||||
|
||||
(defn- notify-deref-watcher! [derefed]
|
||||
(when-some [r *ratom-context*]
|
||||
(let [c (.-captured r)]
|
||||
(if (nil? c)
|
||||
(set! (.-captured r) (array derefed))
|
||||
(.push c derefed)))))
|
||||
|
||||
(defn- check-watches [old new]
|
||||
(when debug
|
||||
(swap! -running + (- (count new) (count old))))
|
||||
new)
|
||||
|
||||
(defn- add-w [this key f]
|
||||
(let [w (.-watches this)]
|
||||
(set! (.-watches this) (check-watches w (assoc w key f)))
|
||||
(set! (.-watchesArr this) nil)))
|
||||
|
||||
(defn- remove-w [this key]
|
||||
(let [w (.-watches this)]
|
||||
(set! (.-watches this) (check-watches w (dissoc w key)))
|
||||
(set! (.-watchesArr this) nil)))
|
||||
|
||||
(defn- notify-w [this old new]
|
||||
(let [w (.-watchesArr this)
|
||||
a (if (nil? w)
|
||||
;; Copy watches to array for speed
|
||||
(->> (.-watches this)
|
||||
(reduce-kv #(doto %1 (.push %2) (.push %3)) #js[])
|
||||
(set! (.-watchesArr this)))
|
||||
w)]
|
||||
(let [len (alength a)]
|
||||
(loop [i 0]
|
||||
(when (< i len)
|
||||
(let [k (aget a i)
|
||||
f (aget a (inc i))]
|
||||
(f k this old new))
|
||||
(recur (+ 2 i)))))))
|
||||
|
||||
(defn- pr-atom [a writer opts s]
|
||||
(-write writer (str "#<" s " "))
|
||||
(pr-writer (binding [*ratom-context* nil] (-deref a)) writer opts)
|
||||
(-write writer ">"))
|
||||
|
||||
|
||||
;;; Queueing
|
||||
|
||||
(defonce ^:private rea-queue nil)
|
||||
|
||||
(defn- rea-enqueue [r]
|
||||
(when (nil? rea-queue)
|
||||
(set! rea-queue (array))
|
||||
(batch/schedule))
|
||||
(.push rea-queue r))
|
||||
|
||||
(defn flush! []
|
||||
(loop []
|
||||
(let [q rea-queue]
|
||||
(when-not (nil? q)
|
||||
(set! rea-queue nil)
|
||||
(dotimes [i (alength q)]
|
||||
(._queued-run (aget q i)))
|
||||
(recur)))))
|
||||
|
||||
(set! batch/ratom-flush flush!)
|
||||
|
||||
|
||||
;;; Atom
|
||||
|
||||
(defprotocol IReactiveAtom)
|
||||
|
||||
(deftype RAtom [^:mutable state meta validator ^:mutable watches]
|
||||
IAtom
|
||||
IReactiveAtom
|
||||
|
||||
IEquiv
|
||||
(-equiv [o other] (identical? o other))
|
||||
|
||||
IDeref
|
||||
(-deref [this]
|
||||
(notify-deref-watcher! this)
|
||||
state)
|
||||
|
||||
IReset
|
||||
(-reset! [a new-value]
|
||||
(when-not (nil? validator)
|
||||
(assert (validator new-value) "Validator rejected reference state"))
|
||||
(let [old-value state]
|
||||
(set! state new-value)
|
||||
(when-not (nil? watches)
|
||||
(notify-w a old-value new-value))
|
||||
new-value))
|
||||
|
||||
ISwap
|
||||
(-swap! [a f] (-reset! a (f state)))
|
||||
(-swap! [a f x] (-reset! a (f state x)))
|
||||
(-swap! [a f x y] (-reset! a (f state x y)))
|
||||
(-swap! [a f x y more] (-reset! a (apply f state x y more)))
|
||||
|
||||
IMeta
|
||||
(-meta [_] meta)
|
||||
|
||||
IPrintWithWriter
|
||||
(-pr-writer [a w opts] (pr-atom a w opts "Atom:"))
|
||||
|
||||
IWatchable
|
||||
(-notify-watches [this old new] (notify-w this old new))
|
||||
(-add-watch [this key f] (add-w this key f))
|
||||
(-remove-watch [this key] (remove-w this key))
|
||||
|
||||
IHash
|
||||
(-hash [this] (goog/getUid this)))
|
||||
|
||||
(defn atom
|
||||
"Like clojure.core/atom, except that it keeps track of derefs."
|
||||
([x] (->RAtom x nil nil nil))
|
||||
([x & {:keys [meta validator]}] (->RAtom x meta validator nil)))
|
||||
|
||||
|
||||
;;; track
|
||||
|
||||
(declare make-reaction)
|
||||
|
||||
(def ^{:private true :const true} cache-key "reagReactionCache")
|
||||
|
||||
(defn- cached-reaction [f o k obj destroy]
|
||||
(let [m (aget o cache-key)
|
||||
m (if (nil? m) {} m)
|
||||
r (m k nil)]
|
||||
(cond
|
||||
(some? r) (-deref r)
|
||||
(nil? *ratom-context*) (f)
|
||||
:else (let [r (make-reaction
|
||||
f :on-dispose (fn [x]
|
||||
(when debug (swap! -running dec))
|
||||
(as-> (aget o cache-key) _
|
||||
(dissoc _ k)
|
||||
(aset o cache-key _))
|
||||
(when (some? obj)
|
||||
(set! (.-reaction obj) nil))
|
||||
(when (some? destroy)
|
||||
(destroy x))))
|
||||
v (-deref r)]
|
||||
(aset o cache-key (assoc m k r))
|
||||
(when debug (swap! -running inc))
|
||||
(when (some? obj)
|
||||
(set! (.-reaction obj) r))
|
||||
v))))
|
||||
|
||||
(deftype Track [f args ^:mutable reaction]
|
||||
IReactiveAtom
|
||||
|
||||
IDeref
|
||||
(-deref [this]
|
||||
(if-some [r reaction]
|
||||
(-deref r)
|
||||
(cached-reaction #(apply f args) f args this nil)))
|
||||
|
||||
IEquiv
|
||||
(-equiv [_ other]
|
||||
(and (instance? Track other)
|
||||
(= f (.-f other))
|
||||
(= args (.-args other))))
|
||||
|
||||
IHash
|
||||
(-hash [_] (hash [f args]))
|
||||
|
||||
IPrintWithWriter
|
||||
(-pr-writer [a w opts] (pr-atom a w opts "Track:")))
|
||||
|
||||
(defn make-track [f args]
|
||||
(Track. f args nil))
|
||||
|
||||
(defn make-track! [f args]
|
||||
(let [t (make-track f args)
|
||||
r (make-reaction #(-deref t)
|
||||
:auto-run true)]
|
||||
@r
|
||||
r))
|
||||
|
||||
(defn track [f & args]
|
||||
{:pre [(ifn? f)]}
|
||||
(make-track f args))
|
||||
|
||||
(defn track! [f & args]
|
||||
{:pre [(ifn? f)]}
|
||||
(make-track! f args))
|
||||
|
||||
;;; cursor
|
||||
|
||||
(deftype RCursor [ratom path ^:mutable reaction
|
||||
^:mutable state ^:mutable watches]
|
||||
IAtom
|
||||
IReactiveAtom
|
||||
|
||||
IEquiv
|
||||
(-equiv [_ other]
|
||||
(and (instance? RCursor other)
|
||||
(= path (.-path other))
|
||||
(= ratom (.-ratom other))))
|
||||
|
||||
Object
|
||||
(_peek [this]
|
||||
(binding [*ratom-context* nil]
|
||||
(-deref this)))
|
||||
|
||||
(_set-state [this oldstate newstate]
|
||||
(when-not (identical? oldstate newstate)
|
||||
(set! state newstate)
|
||||
(when (some? watches)
|
||||
(notify-w this oldstate newstate))))
|
||||
|
||||
IDeref
|
||||
(-deref [this]
|
||||
(let [oldstate state
|
||||
newstate (if-some [r reaction]
|
||||
(-deref r)
|
||||
(let [f (if (satisfies? IDeref ratom)
|
||||
#(get-in @ratom path)
|
||||
#(ratom path))]
|
||||
(cached-reaction f ratom path this nil)))]
|
||||
(._set-state this oldstate newstate)
|
||||
newstate))
|
||||
|
||||
IReset
|
||||
(-reset! [this new-value]
|
||||
(let [oldstate state]
|
||||
(._set-state this oldstate new-value)
|
||||
(if (satisfies? IDeref ratom)
|
||||
(if (= path [])
|
||||
(reset! ratom new-value)
|
||||
(swap! ratom assoc-in path new-value))
|
||||
(ratom path new-value))
|
||||
new-value))
|
||||
|
||||
ISwap
|
||||
(-swap! [a f] (-reset! a (f (._peek a))))
|
||||
(-swap! [a f x] (-reset! a (f (._peek a) x)))
|
||||
(-swap! [a f x y] (-reset! a (f (._peek a) x y)))
|
||||
(-swap! [a f x y more] (-reset! a (apply f (._peek a) x y more)))
|
||||
|
||||
IPrintWithWriter
|
||||
(-pr-writer [a w opts] (pr-atom a w opts (str "Cursor: " path)))
|
||||
|
||||
IWatchable
|
||||
(-notify-watches [this old new] (notify-w this old new))
|
||||
(-add-watch [this key f] (add-w this key f))
|
||||
(-remove-watch [this key] (remove-w this key))
|
||||
|
||||
IHash
|
||||
(-hash [_] (hash [ratom path])))
|
||||
|
||||
(defn cursor
|
||||
[src path]
|
||||
(assert (or (satisfies? IReactiveAtom src)
|
||||
(and (ifn? src)
|
||||
(not (vector? src))))
|
||||
(str "src must be a reactive atom or a function, not "
|
||||
(pr-str src)))
|
||||
(->RCursor src path nil nil nil))
|
||||
|
||||
|
||||
;;; with-let support
|
||||
|
||||
(defn with-let-destroy [v]
|
||||
(when-some [f (.-destroy v)]
|
||||
(f)))
|
||||
|
||||
(defn with-let-values [key]
|
||||
(if-some [c *ratom-context*]
|
||||
(cached-reaction array c key
|
||||
nil with-let-destroy)
|
||||
(array)))
|
||||
|
||||
|
||||
;;;; reaction
|
||||
|
||||
(defprotocol IDisposable
|
||||
(dispose! [this])
|
||||
(add-on-dispose! [this f]))
|
||||
|
||||
(defprotocol IRunnable
|
||||
(run [this]))
|
||||
|
||||
(defn- handle-reaction-change [this sender old new]
|
||||
(._handle-change this sender old new))
|
||||
|
||||
|
||||
(deftype Reaction [f ^:mutable state ^:mutable ^boolean dirty? ^boolean nocache?
|
||||
^:mutable watching ^:mutable watches ^:mutable auto-run
|
||||
^:mutable caught]
|
||||
IAtom
|
||||
IReactiveAtom
|
||||
|
||||
IWatchable
|
||||
(-notify-watches [this old new] (notify-w this old new))
|
||||
(-add-watch [this key f] (add-w this key f))
|
||||
(-remove-watch [this key]
|
||||
(let [was-empty (empty? watches)]
|
||||
(remove-w this key)
|
||||
(when (and (not was-empty)
|
||||
(empty? watches)
|
||||
(nil? auto-run))
|
||||
(dispose! this))))
|
||||
|
||||
IReset
|
||||
(-reset! [a newval]
|
||||
(assert (fn? (.-on-set a)) "Reaction is read only; on-set is not allowed")
|
||||
(let [oldval state]
|
||||
(set! state newval)
|
||||
(.on-set a oldval newval)
|
||||
(notify-w a oldval newval)
|
||||
newval))
|
||||
|
||||
ISwap
|
||||
(-swap! [a f] (-reset! a (f (._peek-at a))))
|
||||
(-swap! [a f x] (-reset! a (f (._peek-at a) x)))
|
||||
(-swap! [a f x y] (-reset! a (f (._peek-at a) x y)))
|
||||
(-swap! [a f x y more] (-reset! a (apply f (._peek-at a) x y more)))
|
||||
|
||||
Object
|
||||
(_peek-at [this]
|
||||
(binding [*ratom-context* nil]
|
||||
(-deref this)))
|
||||
|
||||
(_handle-change [this sender oldval newval]
|
||||
(when-not (or (identical? oldval newval)
|
||||
dirty?)
|
||||
(if (nil? auto-run)
|
||||
(do
|
||||
(set! dirty? true)
|
||||
(rea-enqueue this))
|
||||
(if (true? auto-run)
|
||||
(._run this false)
|
||||
(auto-run this)))))
|
||||
|
||||
(_update-watching [this derefed]
|
||||
(let [new (set derefed)
|
||||
old (set watching)]
|
||||
(set! watching derefed)
|
||||
(doseq [w (s/difference new old)]
|
||||
(-add-watch w this handle-reaction-change))
|
||||
(doseq [w (s/difference old new)]
|
||||
(-remove-watch w this))))
|
||||
|
||||
(_queued-run [this]
|
||||
(when (and dirty? (some? watching))
|
||||
(._run this true)))
|
||||
|
||||
(_try-capture [this f]
|
||||
(try
|
||||
(set! caught nil)
|
||||
(deref-capture f this)
|
||||
(catch :default e
|
||||
(set! state e)
|
||||
(set! caught e)
|
||||
(set! dirty? false))))
|
||||
|
||||
(_run [this check]
|
||||
(let [oldstate state
|
||||
res (if check
|
||||
(._try-capture this f)
|
||||
(deref-capture f this))]
|
||||
(when-not nocache?
|
||||
(set! state res)
|
||||
;; Use = to determine equality from reactions, since
|
||||
;; they are likely to produce new data structures.
|
||||
(when-not (or (nil? watches)
|
||||
(= oldstate res))
|
||||
(notify-w this oldstate res)))
|
||||
res))
|
||||
|
||||
(_set-opts [this {:keys [auto-run on-set on-dispose no-cache]}]
|
||||
(when (some? auto-run)
|
||||
(set! (.-auto-run this) auto-run))
|
||||
(when (some? on-set)
|
||||
(set! (.-on-set this) on-set))
|
||||
(when (some? on-dispose)
|
||||
(set! (.-on-dispose this) on-dispose))
|
||||
(when (some? no-cache)
|
||||
(set! (.-nocache? this) no-cache)))
|
||||
|
||||
IRunnable
|
||||
(run [this]
|
||||
(flush!)
|
||||
(._run this false))
|
||||
|
||||
IDeref
|
||||
(-deref [this]
|
||||
(when-some [e caught]
|
||||
(throw e))
|
||||
(let [non-reactive (nil? *ratom-context*)]
|
||||
(when non-reactive
|
||||
(flush!))
|
||||
(if (and non-reactive (nil? auto-run))
|
||||
(when dirty?
|
||||
(let [oldstate state]
|
||||
(set! state (f))
|
||||
(when-not (or (nil? watches) (= oldstate state))
|
||||
(notify-w this oldstate state))))
|
||||
(do
|
||||
(notify-deref-watcher! this)
|
||||
(when dirty?
|
||||
(._run this false)))))
|
||||
state)
|
||||
|
||||
IDisposable
|
||||
(dispose! [this]
|
||||
(let [s state
|
||||
wg watching]
|
||||
(set! watching nil)
|
||||
(set! state nil)
|
||||
(set! auto-run nil)
|
||||
(set! dirty? true)
|
||||
(doseq [w (set wg)]
|
||||
(-remove-watch w this))
|
||||
(when (some? (.-on-dispose this))
|
||||
(.on-dispose this s))
|
||||
(when-some [a (.-on-dispose-arr this)]
|
||||
(dotimes [i (alength a)]
|
||||
((aget a i) this)))))
|
||||
|
||||
(add-on-dispose! [this f]
|
||||
;; f is called with the reaction as argument when it is no longer active
|
||||
(if-some [a (.-on-dispose-arr this)]
|
||||
(.push a f)
|
||||
(set! (.-on-dispose-arr this) (array f))))
|
||||
|
||||
IEquiv
|
||||
(-equiv [o other] (identical? o other))
|
||||
|
||||
IPrintWithWriter
|
||||
(-pr-writer [a w opts] (pr-atom a w opts (str "Reaction " (hash a) ":")))
|
||||
|
||||
IHash
|
||||
(-hash [this] (goog/getUid this)))
|
||||
|
||||
|
||||
(defn make-reaction [f & {:keys [auto-run on-set on-dispose]}]
|
||||
(let [reaction (->Reaction f nil true false nil nil nil nil)]
|
||||
(._set-opts reaction {:auto-run auto-run
|
||||
:on-set on-set
|
||||
:on-dispose on-dispose})
|
||||
reaction))
|
||||
|
||||
|
||||
|
||||
(def ^:private temp-reaction (make-reaction nil))
|
||||
|
||||
(defn run-in-reaction [f obj key run opts]
|
||||
(let [r temp-reaction
|
||||
res (deref-capture f r)]
|
||||
(when-not (nil? (.-watching r))
|
||||
(set! temp-reaction (make-reaction nil))
|
||||
(._set-opts r opts)
|
||||
(set! (.-f r) f)
|
||||
(set! (.-auto-run r) #(run obj))
|
||||
(aset obj key r))
|
||||
res))
|
||||
|
||||
(defn check-derefs [f]
|
||||
(let [ctx (js-obj)
|
||||
res (in-context ctx f)]
|
||||
[res (some? (.-captured ctx))]))
|
||||
|
||||
|
||||
;;; wrap
|
||||
|
||||
(deftype Wrapper [^:mutable state callback ^:mutable ^boolean changed
|
||||
^:mutable watches]
|
||||
|
||||
IAtom
|
||||
|
||||
IDeref
|
||||
(-deref [this]
|
||||
(when (dev?)
|
||||
(when (and changed (some? *ratom-context*))
|
||||
(warn "derefing stale wrap: "
|
||||
(pr-str this))))
|
||||
state)
|
||||
|
||||
IReset
|
||||
(-reset! [this newval]
|
||||
(let [oldval state]
|
||||
(set! changed true)
|
||||
(set! state newval)
|
||||
(when (some? watches)
|
||||
(notify-w this oldval newval))
|
||||
(callback newval)
|
||||
newval))
|
||||
|
||||
ISwap
|
||||
(-swap! [a f] (-reset! a (f state)))
|
||||
(-swap! [a f x] (-reset! a (f state x)))
|
||||
(-swap! [a f x y] (-reset! a (f state x y)))
|
||||
(-swap! [a f x y more] (-reset! a (apply f state x y more)))
|
||||
|
||||
IEquiv
|
||||
(-equiv [_ other]
|
||||
(and (instance? Wrapper other)
|
||||
;; If either of the wrappers have changed, equality
|
||||
;; cannot be relied on.
|
||||
(not changed)
|
||||
(not (.-changed other))
|
||||
(= state (.-state other))
|
||||
(= callback (.-callback other))))
|
||||
|
||||
IWatchable
|
||||
(-notify-watches [this old new] (notify-w this old new))
|
||||
(-add-watch [this key f] (add-w this key f))
|
||||
(-remove-watch [this key] (remove-w this key))
|
||||
|
||||
IPrintWithWriter
|
||||
(-pr-writer [a w opts] (pr-atom a w opts "Wrap:")))
|
||||
|
||||
(defn make-wrapper [value callback-fn args]
|
||||
(->Wrapper value
|
||||
(util/make-partial-fn callback-fn args)
|
||||
false nil))
|
||||
|
||||
|
||||
|
||||
|
||||
#_(do
|
||||
(defn ratom-perf []
|
||||
(set! debug false)
|
||||
(dotimes [_ 10]
|
||||
(let [nite 100000
|
||||
a (atom 0)
|
||||
f (fn []
|
||||
(quot @a 10))
|
||||
mid (make-reaction f)
|
||||
res (track! (fn []
|
||||
;; (with-let [x 1])
|
||||
;; @(track f)
|
||||
(inc @mid)
|
||||
))]
|
||||
@res
|
||||
(time (dotimes [x nite]
|
||||
(swap! a inc)
|
||||
(flush!)))
|
||||
(dispose! res))))
|
||||
(ratom-perf))
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user