refactor coord resolution for performance

README.md

@@ -7,7 +7,7 @@ Respo: A virtual DOM library in ClojureScript
 [![Respo](https://img.shields.io/clojars/v/respo/respo.svg)](https://clojars.org/respo/respo)
 
 ```clojure
-[respo "0.13.5"]
+[respo "0.13.6"]
 ```
 
 * Home http://respo-mvc.org

macros/respo/core.clj

@@ -6,9 +6,10 @@
   (assert (coll? params) "2nd argument should be a collection")
   (assert (some? (last body)) "defcomp should return a component")
   `(defn ~comp-name [~@params]
+    (respo.core/extract-effects-list
      (merge respo.schema/component
        {:name ~(keyword comp-name),
-        :tree (do ~@body)})))
+        :tree (do ~@body)}))))
 
 (def support-elements '[a body br button canvas code div footer
                         h1 h2 head header html hr i img input li link video audio

package.json

@@ -1,6 +1,6 @@
 {
   "name": "respo",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "description": "Virtual DOM library",
   "main": "index.js",
   "scripts": {

release.edn

@@ -1,4 +1,4 @@
-{:version "0.13.5",
+{:version "0.13.6",
  :group-id "respo",
  :artifact-id "respo",
  :skip-tag true,

shadow-cljs.edn

@@ -15,6 +15,7 @@
       :modules {
         :main {:init-fn respo.main/main!}
       }
+      :devtools {:loader-mode :script}
       :release {:output-dir "dist/"}
     }
     :test {:target :node-script, :output-to "target/test.js", :main respo.test.main/main!}

src/respo/app/comp/todolist.cljs

@@ -95,7 +95,7 @@
        (div
         {:spell-check true, :style style-toolbar}
         (div
-         {:style widget/button, :on-click (if (:locked? state) (fn [e d!] (d! :clear nil)))}
+         {:style widget/button, :on-click (if (:locked? state) nil (fn [e d!] (d! :clear)))}
          (<> "Clear2"))
         (=< 8 nil)
         (div

src/respo/controller/client.cljs

@@ -11,7 +11,7 @@
 (defn activate-instance! [entire-dom mount-point deliver-event]
   (let [listener-builder (fn [event-name] (build-listener event-name deliver-event))]
     (set! (.-innerHTML mount-point) "")
-    (.appendChild mount-point (make-element entire-dom listener-builder))))
+    (.appendChild mount-point (make-element entire-dom listener-builder []))))
 
 (defn patch-instance! [changes mount-point deliver-event]
   (let [listener-builder (fn [event-name] (build-listener event-name deliver-event))]

src/respo/core.cljs

@@ -1,13 +1,14 @@
 
 (ns respo.core
-  (:require [respo.render.expand :refer [render-app]]
-            [respo.controller.resolve :refer [build-deliver-event]]
+  (:require [respo.controller.resolve :refer [build-deliver-event]]
             [respo.render.diff :refer [find-element-diffs]]
             [respo.render.effect :refer [collect-mounting]]
             [respo.util.format :refer [purify-element mute-element]]
             [respo.controller.client :refer [activate-instance! patch-instance!]]
-            [respo.util.list :refer [pick-attrs pick-event val-exists? detect-func-in-map?]]
-            [respo.util.detect :refer [component? element?]]
+            [respo.util.list
+             :refer
+             [pick-attrs pick-event val-exists? detect-func-in-map? filter-first]]
+            [respo.util.detect :refer [component? element? effect?]]
             [respo.util.dom :refer [compare-to-dom!]]
             [respo.schema :as schema]
             [respo.util.comparator :refer [compare-xy]]
@@ -65,50 +66,56 @@
 
 (def element-type (if (exists? js/Element) js/Element js/Error))
 
-(defn render-element [markup] (render-app markup))
+(defn extract-effects-list [m]
+  (let [tree (:tree m)]
+    (if (vector? tree)
+      (let [node-tree (filter-first
+                       (fn [x] (and (map? x) (or (component? x) (element? x))))
+                       tree)
+            effects-list (filter effect? tree)]
+        (merge m {:tree node-tree, :effects effects-list}))
+      m)))
 
-(defn mount-app! [target markup dispatch!]
+(defn mount-app! [target element dispatch!]
   (assert (instance? element-type target) "1st argument should be an element")
-  (assert (component? markup) "2nd argument should be a component")
-  (let [element (render-element markup)
+  (assert (component? element) "2nd argument should be a component")
+  (let [element element
         deliver-event (build-deliver-event *global-element dispatch!)
         *changes (atom [])
         collect! (fn [x]
-                   (assert (= 3 (count x)) "change op should has length 3")
+                   (assert (= 4 (count x)) "change op should has length 3")
                    (swap! *changes conj x))]
     (comment println "mount app")
-    (activate-instance! (purify-element element) target deliver-event)
-    (collect-mounting collect! [] element true)
+    (activate-instance! element target deliver-event)
+    (collect-mounting collect! [] [] element true)
     (patch-instance! @*changes target deliver-event)
     (reset! *global-element element)))
 
-(defn realize-ssr! [target markup dispatch!]
+(defn realize-ssr! [target element dispatch!]
   (assert (instance? element-type target) "1st argument should be an element")
-  (assert (component? markup) "2nd argument should be a component")
-  (let [element (render-element markup)
-        app-element (.-firstElementChild target)
+  (assert (component? element) "2nd argument should be a component")
+  (let [app-element (.-firstElementChild target)
         *changes (atom [])
         collect! (fn [x]
-                   (assert (= 3 (count x)) "change op should has length 3")
+                   (assert (= 4 (count x)) "change op should has length 3")
                    (swap! *changes conj x))
         deliver-event (build-deliver-event *global-element dispatch!)]
     (if (nil? app-element) (throw (js/Error. "Detected no element from SSR!")))
     (compare-to-dom! (purify-element element) app-element)
-    (collect-mounting collect! [] element true)
+    (collect-mounting collect! [] [] element true)
     (patch-instance! @*changes target deliver-event)
     (reset! *global-element (mute-element element))))
 
-(defn rerender-app! [target markup dispatch!]
+(defn rerender-app! [target element dispatch!]
   (tick-calling-loop!)
-  (let [element (render-element markup)
-        deliver-event (build-deliver-event *global-element dispatch!)
+  (let [deliver-event (build-deliver-event *global-element dispatch!)
         *changes (atom [])
         collect! (fn [x]
-                   (assert (= 3 (count x)) "change op should has length 3")
+                   (assert (= 4 (count x)) "change op should has length 3")
                    (swap! *changes conj x))]
     (comment println @*global-element)
     (comment println "Changes:" (pr-str (mapv (partial take 2) @*changes)))
-    (find-element-diffs collect! [] @*global-element element)
+    (find-element-diffs collect! [] [] @*global-element element)
     (let [logger @*changes-logger]
       (if (some? logger) (logger @*global-element element @*changes)))
     (patch-instance! @*changes target deliver-event)