cheetah dynamic style

demo/src/demo/page/cheetah.cljs

@@ -27,6 +27,22 @@
                (reset! ds-a :load-error))))
 
 
+(defn red-color [row]
+  ;(println "red-color for: " row)
+  (clj->js {:color "red"}))
+
+(defn blue-color [row]
+  ;(println "blue-color for: " row)
+  (clj->js {:color "blue"}))
+
+(defn bool-color [row]
+  (let [row-clj (js->clj row)
+        v (get row-clj "cross-up-c")
+        color (if v "blue" "red")]
+    ;(println row-clj)
+    ;(println "bool color: " color " val: " v)
+    (clj->js {:color color})))
+
 (defn page [_]
   [:div.h-screen.w-screen.bg-blue-100
    ;; aggrid that has its data
@@ -63,25 +79,34 @@
      [cheetah {:style {:width "100%" :height "100%"}
                :columns [; bar
                          {:field "asset" :caption "a" :width 90}
-                         {:field "date" :caption "d" :width 220}
-                         {:field "open" :caption "o" :width 90}
+                         {:field "date" :caption "d" :width 220
+                          ;:style 'demo.page.cheetah/bad-fn
+                          }
+                         {:field "open" :caption "o" :width 90
+                          :style 'demo.page.cheetah/red-color
+                          }
                          {:field "high" :caption "h" :width 90}
                          {:field "low" :caption "l" :width 90}
-                         {:field "close" :caption "c" :width 90}
+                         {:field "close" :caption "c" :width 90
+                          :style blue-color
+                          }
                          {:field "volume" :caption "v" :width 90}
                          ;
                          {:field "atr-band-lower" :caption "BL" :width 50}
                          {:field "atr-band-upper" :caption "BU" :width 50}
                          {:field  "doji" :caption "doji" :width 50}
 
-                         {:field  "below-band" :caption "B?" :width 50}
+                         {:field  "below-band" :caption "B?" :width 50
+                          :style {:bgColor "#5f5" }}
                          {:field  "cross-down" :caption "XD" :width 50}
                          {:field  "cross-down-c" :caption "XD_" :width 50}
                          {:field  "long-signal" :caption "LS" :width 50}
 
                          {:field  "above-band" :caption "A?" :width 50}
                          {:field  "cross-up" :caption "XU" :width 50}
-                         {:field  "cross-up-c" :caption "XU_" :width 50}
+                         {:field  "cross-up-c" :caption "XU_" :width 50
+                          :style demo.page.cheetah/bool-color
+                          }
                          {:field  "short-signal" :caption "SS" :width 50}
 
                          {:field "entry" :caption "entry" :width 50}

src/rtable/cheetah.cljs

@@ -1,42 +1,54 @@
 (ns rtable.cheetah
- (:require
-  [reagent.core :as reagent]
-  [reagent.dom]
-  ["cheetah-grid" :as cheetah-grid :refer [ListGrid data]]
+  (:require
+   [reagent.core :as reagent]
+   [reagent.dom]
+   [promesa.core :as p]
+   ["cheetah-grid" :as cheetah-grid :refer [ListGrid data]]
    [tech.v3.dataset :as tmlds]
-  ))
+   [rtable.resolve :refer [resolve-col]]))
 
 (def CachedDataSource (.-CachedDataSource data))
 
 (defn create-datasource [ds]
-  (println "creating datasource..")
+  ;(println "creating datasource..")
   (let [count (tmlds/row-count ds)
         ds (CachedDataSource. (clj->js {:get (fn [row-idx]
-                                               (println "getting row-idx: " row-idx)
+                                               ;(println "getting row-idx: " row-idx)
                                                (clj->js (tmlds/row-at ds row-idx)))
-                                        :length count}))
-        ]
-    (println "ds count: " count " ds: " ds)
+                                        :length count}))]
+    ;(println "ds count: " count " ds: " ds)
     ds))
 
-(defn render-cheetah [node columns data ds]
+(defn render-cheetah-impl [node columns data ds]
   (if ds
     (ListGrid.
-      (clj->js {:parentElement node
-                :header columns
-                :dataSource (create-datasource ds)}))
+     (clj->js {:parentElement node
+               :header columns
+               :dataSource (create-datasource ds)}))
     (ListGrid.
-      (clj->js {:parentElement node
-                :header columns
-                :records data}))))
-
+     (clj->js {:parentElement node
+               :header columns
+               :records data}))))
 
 
+(defn render-cheetah [node columns resolve? data ds]
+  (if resolve?
+    (-> (resolve-col columns [:style])
+        (p/then (fn [columns]
+                  (println "resolved cols: " columns)
+                  (render-cheetah-impl node columns data ds)))
+        (p/catch (fn [err]
+                   (println "error resolving columns: " err))))
+    (render-cheetah-impl node columns data ds)))
 
 (defn cheetah
-  [{:keys [style class columns data ds]
+  [{:keys [style class
+           columns
+           resolve?
+           data ds]
     :or {style {}
-         class ""}}]
+         class ""
+         resolve? true}}]
   (let [uuid 28]
     ; https://github.com/reagent-project/reagent/blob/master/doc/CreatingReagentComponents.md
     (reagent/create-class
@@ -49,13 +61,13 @@
       :component-did-mount (fn [this] ; oldprops oldstate snapshot
                              ;(println "c-d-m: " this)
                              ;(info (str "jsrender init data: " data))
-                             (render-cheetah (reagent.dom/dom-node this) columns data ds))
+                             (render-cheetah (reagent.dom/dom-node this) columns resolve? data ds))
       :component-did-update (fn [this old-argv]
                               (let [new-argv (rest (reagent/argv this))
                                     [arg1] new-argv
                                     {:keys [data-js]} arg1]
                                 ;(println "component did update: " this "argv: " new-argv)
-                                (render-cheetah (reagent.dom/dom-node this) columns data ds)))})))
+                                (render-cheetah (reagent.dom/dom-node this) columns resolve? data ds)))})))
 
 
 

src/rtable/resolve.cljs

@@ -0,0 +1,95 @@
+(ns rtable.resolve
+  (:require
+   [promesa.core :as p]
+   [sci.impl.vars :as vars]
+   [webly.spa.resolve :refer [get-resolver]]))
+
+; replace symbols with functions
+; functions are resolved via requiring-resolve which returns a promesa promise
+
+
+
+(defn resolve-symbols
+  "input: seq of symbol
+   output: a promise, when resolved: map keys:symbol values:fn"
+  [symbols]
+  ;(println "resolve-symbols: " (pr-str symbols))
+  (let [symbols (->> symbols (into #{}) (into [])) ; in case some symbols are duplicates
+        requiring-resolve (get-resolver)
+        promises (map requiring-resolve symbols)
+        all (p/all promises)
+        result (p/deferred)]
+    (p/then all
+            (fn [ps]
+              (println "resolve-symbols: successfully resolved all symbols!")
+              ;(println "symbols: " (pr-str symbols))
+              ;(println "ps: " (pr-str ps))
+              (let [tuplets (map (fn [s f]
+                                   ;(println "tuplet: " (pr-str [s f]))
+                                   [s f]
+                                   [s (vars/var-get f)]
+                                   ) symbols ps)
+                    d (into {} tuplets)]
+                ;(println "tuplets: " (pr-str tuplets))
+                ;(println "d: " (pr-str d))
+                (p/resolve! result d))))
+    (p/catch all (fn [e]
+                   (println "resolve-symbols: error in resolving all symbols!")
+                   (println "resolve-symbols error: " e)
+                   (p/reject! result e)))
+    result))
+
+(defn symbols-for-col [cols col-key]
+  (->> cols
+       (map col-key)
+       (filter symbol?)))
+
+(defn symbols-for-cols [cols col-keys]
+  (let [symbol-lists (map #(symbols-for-col cols %) col-keys)]
+    (reduce concat [] symbol-lists)))
+
+(defn update-symbol-col [d m k]
+  (let [v (k m)]
+    (if (symbol? v)
+      (update m k #(get d %))
+      m)))
+
+(defn update-col [d m k]
+  (let [s (k m)]
+    (if (symbol? s)
+      (if-let [f (get d s)]
+        (assoc {} k f)
+        (do (println "could not resolve column: " k "symbol: " s)
+            {}))
+      {})))
+
+(defn update-symbol-cols [d m ks]
+  (let [col-prior m
+        changes (map #(update-col d m %) ks)
+        col-after (reduce merge m changes)]
+    ;(println "prior: " col-prior)
+    ;(println "after: " col-after)
+    col-after))
+
+(defn resolve-col [cols col-keys]
+  (println "resolving columns:" col-keys "for " (count cols) "columns ...")
+  (let [symbols (symbols-for-cols cols col-keys)
+        p-r (resolve-symbols symbols)
+        result (p/deferred)]
+    (p/then p-r (fn [d]
+                  (println "all columns have been resolved successfully!")
+                  ;(println "dict: " (pr-str d))
+                  (->>
+                   (map #(update-symbol-cols d % col-keys) cols)
+                   (p/resolve! result))))
+    (p/catch p-r (fn [e]
+                   (println "Error in resolving all columns!")
+                   (println "resolve-col error: " e)
+                   (p/reject! result e)))
+    result))
+
+(defn resolve-cols
+  "resolves {:format :render-cell} in all columns
+   returns a promise"
+  [cols]
+  (resolve-col cols [:format :render-cell :attrs]))