fix double-calling HoCs and also don't wrap them in a list

nosco · Mar 26, 2019 · aa1b090 · aa1b090
1 parent e503744
commit aa1b090
Show file tree

Hide file tree

Showing 2 changed files with 14 additions and 15 deletions.
diff --git a/examples/workshop/core.cljs b/examples/workshop/core.cljs
@@ -244,15 +244,17 @@
     hoc))
 
 (defn hoc-example2 [color]
-  (fn [c]
+  (fn example2 [c]
     (let [hoc (hx/fnc Example [_]
                       [:div {:style {:color color}} [c]])]
       (set! (.-displayName hoc) (str "Color(" (.-displayName c) ")"))
       hoc)))
 
 (hx/defnc HoCWrapper [_]
   {:wrap [hoc-example
-          (hoc-example2 "green")]}
+          (react/memo =)
+          ((hoc-example2 "green"))
+          ]}
   [:span "HoC should be header and green"])
 
 (dc/defcard hoc-wrapper

diff --git a/src/hx/react.clj b/src/hx/react.clj
@@ -39,13 +39,15 @@
              (map (fn [x] `(assert ~x)) (:pre (first body))))
          (hx.react/parse-body
           ;; post-conditions
-          ~(if (and opts-map? (:post (first body)))
-             ;; save hiccup value of body
-             `(let [~ret (do ~@(rest body))]
-                ;; apply post-conditions
-                ~@(map (fn [x] `(assert ~(replace {'% ret} x)))
-                       (:post (first body)))
-                ~ret)
+          ~(if opts-map?
+             (if (:post (first body))
+               ;; save hiccup value of body
+               `(let [~ret (do ~@(rest body))]
+                  ;; apply post-conditions
+                  ~@(map (fn [x] `(assert ~(replace {'% ret} x)))
+                         (:post (first body)))
+                  ~ret)
+               `(do ~@(rest body)))
              ;; if no post-conditions, do nothing
              `(do ~@body)))))))
 
@@ -60,12 +62,7 @@
              (when js/goog.DEBUG
                (set! (.-displayName ~wrapped-name) ~(str *ns* "/" display-name)))
              (def ~display-name (-> ~wrapped-name
-                                    ~@(-> body first :wrap
-                                          ;; wrap as a list so that you can do
-                                          ;; like `[hocA (returns-hocB some-config)]`
-                                          ;; and `(returns-hocB some-config)` will be
-                                          ;; called to return an HoC
-                                          (as-> w (map list w)))))))
+                                    ~@(-> body first :wrap)))))
 
       `(do (def ~display-name ~(fnc* display-name props-bindings body))
            (when js/goog.DEBUG