enhance performance

Author: sprocketc

src/renderer/attribute/hierarchy.cljs

@@ -5,5 +5,9 @@
 (defmulti form-element (fn [tag k _v _attrs] [tag k]))
 
 (defmethod update-attr :default
-  [el k f & more]
-  (apply update-in el [:attrs k] f more))
+  ([el k f]
+   (update-in el [:attrs k] f))
+  ([el k f arg]
+   (update-in el [:attrs k] f arg))
+  ([el k f arg & more]
+   (apply update-in el [:attrs k] f arg more)))

src/renderer/attribute/impl/length.cljs

@@ -48,9 +48,17 @@
      [views/icon "plus"]]]])
 
 (defmethod attribute.hierarchy/update-attr ::length
-  [el k f & more]
-  (update-in el [:attrs k] #(apply utils.length/transform % f more)))
+  ([el k f]
+   (update-in el [:attrs k] #(utils.length/transform % f)))
+  ([el k f arg]
+   (update-in el [:attrs k] #(utils.length/transform % f arg)))
+  ([el k f arg & more]
+   (update-in el [:attrs k] #(apply utils.length/transform % f arg more))))
 
 (defmethod attribute.hierarchy/update-attr ::positive-length
-  [el k f & more]
-  (update-in el [:attrs k] utils.length/transform (fn [v] (max 0 (apply f v more)))))
+  ([el k f]
+   (update-in el [:attrs k] utils.length/transform (fn [v] (max 0 (f v)))))
+  ([el k f arg]
+   (update-in el [:attrs k] utils.length/transform (fn [v] (max 0 (f v arg)))))
+  ([el k f arg & more]
+   (update-in el [:attrs k] utils.length/transform (fn [v] (max 0 (apply f v arg more))))))

src/renderer/attribute/views.cljs

@@ -60,7 +60,7 @@
                (utils.attribute/compatibility tag attr)
                (utils.attribute/compatibility tag))
         support-data (:support data)
-        property (when attr (utils.attribute/property-data attr))
+        property (when attr (utils.attribute/property-data-memo attr))
         spec-url (or (:spec_url data) (:href property))
         spec-url (if (vector? spec-url) (first spec-url) spec-url)
         mdn-url (or (when data (or (:mdn_url data) (construct-mdn-url (name attr))))
@@ -175,7 +175,7 @@
 (defn label
   [tag k]
   (let [clicked-element @(rf/subscribe [::app.subs/clicked-element])
-        property (utils.attribute/property-data k)
+        property (utils.attribute/property-data-memo k)
         dispatch-tag (if (contains? (methods attribute.hierarchy/description) [tag k])
                        tag
                        :default)
@@ -204,7 +204,7 @@
 
 (defn row
   [k v locked? tag]
-  (let [property (utils.attribute/property-data k)
+  (let [property (utils.attribute/property-data-memo k)
         initial (:initial property)
         dispatch-tag (if (contains? (methods attribute.hierarchy/form-element) [tag k])
                        tag

src/renderer/utils/attribute.cljs

@@ -247,10 +247,14 @@
             css-property
             [:appliesto :computed :percentages :animationType])))
 
+(def property-data-memo (memoize property-data))
+
+(defonce whitespace-regex #"\s*[\s,]\s*")
+
 (m/=> str->seq [:-> string? vector?])
 (defn str->seq
   [s]
-  (-> s string/trim (string/split #"\s*[\s,]\s*")))
+  (-> s string/trim (string/split whitespace-regex)))
 
 (m/=> points->vec [:function
                    [:-> string? vector?]
@@ -283,16 +287,18 @@
         (keys)
         (zipmap (repeat "")))))
 
+(def ->attrs-memo (memoize ->attrs))
+
 (m/=> defaults [:-> Tag Attrs])
 (defn defaults
   [tag]
   (merge (when (element.db/tag? tag)
-           (merge (->attrs (or (tag (:elements svg-data)) {}))
+           (merge (->attrs-memo (or (tag (:elements svg-data)) {}))
                   (when (or (isa? tag ::element.hierarchy/shape)
                             (isa? tag ::element.hierarchy/container))
                     (zipmap core (repeat "")))))
          (when (contains? #{:animateMotion :animateTransform} tag)
-           (->attrs (:animate (:elements svg-data))))
+           (->attrs-memo (:animate (:elements svg-data))))
          (zipmap (:attrs (element.hierarchy/properties tag)) (repeat ""))))
 
 (def defaults-memo (memoize defaults))

src/renderer/utils/bounds.cljs

@@ -1,6 +1,5 @@
 (ns renderer.utils.bounds
   (:require
-   [clojure.core.matrix :as matrix]
    [malli.core :as m]
    [renderer.snap.db :refer [SnapOptions]]
    [renderer.utils.dom :refer [DomElement]]
@@ -31,27 +30,30 @@
 (defn union
   "Returns the bounding box that contains the provided collection of bounds."
   [& bbox]
-  (vec (concat (apply map min (map #(take 2 %) bbox))
-               (apply map max (map #(drop 2 %) bbox)))))
+  (reduce (fn [[a-min-x a-min-y a-max-x a-max-y] [b-min-x b-min-y b-max-x b-max-y]]
+            [(min a-min-x b-min-x)
+             (min a-min-y b-min-y)
+             (max a-max-x b-max-x)
+             (max a-max-y b-max-y)])
+          bbox))
 
 (m/=> ->dimensions [:-> BBox Vec2])
 (defn ->dimensions
   "Converts a bounding box to [width height]."
   [[min-x min-y max-x max-y]]
-  (matrix/sub [max-x max-y] [min-x min-y]))
+  [(- max-x min-x) (- max-y min-y)])
 
 (m/=> center [:-> BBox Vec2])
 (defn center
   "Calculates the center of a bounding box."
-  [bbox]
-  (matrix/add (take 2 bbox)
-              (matrix/div (->dimensions bbox) 2)))
+  [[min-x min-y max-x max-y]]
+  [(+ min-x (/ (- max-x min-x) 2))
+   (+ min-y (/ (- max-y min-y) 2))])
 
 (m/=> intersect? [:-> BBox BBox boolean?])
 (defn intersect?
   "Tests whether the provided set of bounds intersect."
-  [[a-min-x a-min-y a-max-x a-max-y]
-   [b-min-x b-min-y b-max-x b-max-y]]
+  [[a-min-x a-min-y a-max-x a-max-y] [b-min-x b-min-y b-max-x b-max-y]]
   (not (or (> b-min-x a-max-x)
            (< b-max-x a-min-x)
            (> b-min-y a-max-y)

src/renderer/utils/element.cljs

@@ -31,10 +31,12 @@
   [el]
   (or (svg? el) (root? el)))
 
+(def properties-memo (memoize element.hierarchy/properties))
+
 (m/=> properties [:-> Element [:maybe map?]])
 (defn properties
   [el]
-  (-> el :tag element.hierarchy/properties))
+  (-> el :tag properties-memo))
 
 (m/=> ratio-locked? [:-> Element boolean?])
 (defn ratio-locked?
@@ -172,8 +174,11 @@
 (defn ->dom-element
   [el]
   (let [{:keys [tag attrs]} el
-        dom-el (js/document.createElementNS "http://www.w3.org/2000/svg" (name tag))]
-    (doseq [[k v] attrs]
-      (when (supported-attr? (dissoc el :attrs) k)
-        (.setAttributeNS dom-el nil (name k) v)))
+        dom-el (js/document.createElementNS "http://www.w3.org/2000/svg" (name tag))
+        el (dissoc el :attrs)
+        supported-attrs (keep (fn [[k v]]
+                                (when (supported-attr? el k)
+                                  [k v])) attrs)]
+    (doseq [[k v] supported-attrs]
+      (.setAttributeNS dom-el nil (name k) v))
     dom-el))

src/renderer/utils/length.cljs

@@ -1,5 +1,6 @@
 (ns renderer.utils.length
   (:require
+   [clojure.string :as string]
    [malli.core :as m]
    [renderer.utils.unit :as utils.unit]))
 
@@ -9,17 +10,17 @@
 
 ;; TODO: Find an agnostic way to handle percentages (we need to pass a base).
 (defonce unit-to-pixel-map
-  {:px 1
-   :ch 8
-   :ex 7.15625
-   :em 16
-   :rem 16
-   :in ppi
-   :cm (/ ppi 2.54)
-   :mm (/ ppi 25.4)
-   :pt (/ ppi 72)
-   :pc (/ ppi 6)
-   :% 1})
+  {"px" 1
+   "ch" 8
+   "ex" 7.15625
+   "em" 16
+   "rem" 16
+   "in" ppi
+   "cm" (/ ppi 2.54)
+   "mm" (/ ppi 25.4)
+   "pt" (/ ppi 72)
+   "pc" (/ ppi 6)
+   "%" 1})
 
 (m/=> valid-unit? [:-> string? boolean?])
 (defn valid-unit?
@@ -29,11 +30,10 @@
 (m/=> multiplier [:-> string? number?])
 (defn multiplier
   "Returns the multiplier by unit.
-   If the unit is invalid, it fallbacks to :px (1)."
+   If the unit is invalid, it fallbacks to px (1)."
   [s]
-  (get unit-to-pixel-map (if (valid-unit? s)
-                           (utils.unit/->key s)
-                           :px)))
+  (or (get unit-to-pixel-map (string/lower-case s))
+      1))
 
 (m/=> ->px [:-> number? string? number?])
 (defn ->px

src/renderer/utils/unit.cljs

@@ -3,16 +3,12 @@
    [clojure.string :as string]
    [malli.core :as m]))
 
-(m/=> ->key [:-> string? keyword?])
-(defn ->key
-  "Converts the string unit to a lower-cased keyword."
-  [s]
-  (keyword (string/lower-case s)))
+(defonce unit-regex #"[\d.\-\+]*\s*(.*)")
 
 (m/=> match [:-> string? string?])
 (defn match
   [s]
-  (second (re-matches #"[\d.\-\+]*\s*(.*)" s)))
+  (second (re-matches unit-regex s)))
 
 (m/=> parse [:-> [:or string? number? nil?] [:tuple number? string?]])
 (defn parse

test/utils/unit_test.cljs

@@ -3,12 +3,6 @@
    [cljs.test :refer-macros [deftest testing are]]
    [renderer.utils.unit :as utils.unit]))
 
-(deftest test-->key
-  (testing "convert unit string to keyword"
-    (are [x y] (= x y)
-      :px (utils.unit/->key "px")
-      :px (utils.unit/->key "Px"))))
-
 (deftest test-unit
   (testing "match unit"
     (are [x y] (= x y)