support initial attribute value

Author: sprocketc

src/renderer/attribute/hierarchy.cljs

@@ -1,9 +1,11 @@
 (ns renderer.attribute.hierarchy)
 
+(defmulti initial (fn [tag k] [tag k]))
 (defmulti update-attr (fn [_ k & _more] k))
 (defmulti description (fn [tag k] [tag k]))
 (defmulti form-element (fn [tag k _v _attrs] [tag k]))
 
+(defmethod initial :default [_tag _k] nil)
 (defmethod update-attr :default
   ([el k f]
    (update-in el [:attrs k] f))

src/renderer/attribute/impl/length.cljs

@@ -47,6 +47,8 @@
       :on-click #(rf/dispatch [::element.events/update-attr k inc])}
      [views/icon "plus"]]]])
 
+(defmethod attribute.hierarchy/initial ::length [_tag _attr] 0)
+
 (defmethod attribute.hierarchy/update-attr ::length
   ([el k f]
    (update-in el [:attrs k] #(utils.length/transform % f)))

src/renderer/attribute/views.cljs

@@ -204,8 +204,7 @@
 
 (defn row
   [k v locked? tag]
-  (let [property (utils.attribute/property-data-memo k)
-        initial (:initial property)
+  (let [initial (utils.attribute/initial-memo tag k)
         dispatch-tag (if (contains? (methods attribute.hierarchy/form-element) [tag k])
                        tag
                        :default)]

src/renderer/element/impl/custom/blob.cljs

@@ -13,6 +13,7 @@
    [renderer.element.subs :as-alias element.subs]
    [renderer.event.impl.pointer :as event.impl.pointer]
    [renderer.tool.views :as tool.views]
+   [renderer.utils.attribute :as utils.attribute]
    [renderer.utils.element :as utils.element]
    [renderer.utils.length :as utils.length]
    [renderer.utils.svg :as utils.svg]
@@ -71,6 +72,12 @@
   []
   "The size of the bounding box.")
 
+(defmethod attr.hierarchy/initial [:blob :extraPoints] [] "0")
+
+(defmethod attr.hierarchy/initial [:blob :randomness] [] "0")
+
+(defmethod attr.hierarchy/initial [:blob :size] [] "0")
+
 (defmethod element.hierarchy/properties :blob
   []
   {:icon "blob"
@@ -135,8 +142,8 @@
   [el]
   (let [{{:keys [x y]} :attrs} el
         [x y] (mapv utils.length/unit->px [x y])
-        options (->> [:seed :extraPoints :randomness :size]
-                     (select-keys (:attrs el))
+        options (->> (select-keys (:attrs el) [:seed :extraPoints :randomness :size])
+                     (merge (utils.attribute/defaults-with-vals :blob))
                      (reduce (fn [options [k v]] (assoc options k (int v))) {})
                      (clj->js))]
     (-> blobs

src/renderer/utils/attribute.cljs

@@ -5,6 +5,7 @@
    [camel-snake-kebab.core :as camel-snake-kebab]
    [clojure.string :as string]
    [malli.core :as m]
+   [renderer.attribute.hierarchy :as attribute.hierarchy]
    [renderer.element.db :as element.db :refer [Attrs Tag]]
    [renderer.element.hierarchy :as element.hierarchy]))
 
@@ -235,7 +236,8 @@
 (defn enhance-data-readability
   [property k]
   (cond-> property
-    (and (get property k) (string? (get property k)))
+    (and (get property k)
+         (string? (get property k)))
     (update k #(-> (camel-snake-kebab/->kebab-case-string %)
                    (string/replace "-" " ")))))
 
@@ -302,3 +304,21 @@
          (zipmap (:attrs (element.hierarchy/properties tag)) (repeat ""))))
 
 (def defaults-memo (memoize defaults))
+
+(m/=> initial [:-> Tag keyword? string?])
+(defn initial
+  [tag k]
+  (let [dispatch-tag (if (contains? (methods attribute.hierarchy/initial) [tag k])
+                       tag
+                       :default)]
+    (or (attribute.hierarchy/initial dispatch-tag k)
+        (:initial (property-data-memo k)))))
+
+(def initial-memo (memoize initial))
+
+(m/=> defaults-with-vals [:-> Tag Attrs])
+(defn defaults-with-vals
+  [tag]
+  (into {}
+        (map (fn [[k v]]
+               [k (or (initial-memo tag k) v)])) (defaults-memo tag)))

src/renderer/utils/length.cljs

@@ -2,14 +2,14 @@
   (:require
    [clojure.string :as string]
    [malli.core :as m]
+   [renderer.element.db :as db :refer [Tag]]
+   [renderer.utils.attribute :as utils.attribute]
    [renderer.utils.unit :as utils.unit]))
 
 (defonce ppi 96)
 
-(defonce units #{"px" "ch" "ex" "em" "rem" "in" "cm" "mm" "pt" "pc" "%"})
-
 ;; TODO: Find an agnostic way to handle percentages (we need to pass a base).
-(defonce unit-to-pixel-map
+(defonce units
   {"px" 1
    "ch" 8
    "ex" 7.15625
@@ -32,7 +32,7 @@
   "Returns the multiplier by unit.
    If the unit is invalid, it fallbacks to px (1)."
   [s]
-  (or (get unit-to-pixel-map (string/lower-case s))
+  (or (get units (string/lower-case s))
       1))
 
 (m/=> ->px [:-> number? string? number?])
@@ -45,13 +45,23 @@
   [n unit]
   (/ n (multiplier unit)))
 
-(m/=> unit->px [:-> [:or string? number? nil?] number?])
+(m/=> unit->px [:function
+                [:-> [:or string? number? nil?] number?]
+                [:-> [:or string? number? nil?] number? number?]
+                [:-> [:or string? number? nil?] Tag keyword? number?]])
 (defn unit->px
-  [v]
-  (let [[n unit] (utils.unit/parse v)]
-    (if (empty? unit)
-      n
-      (if (valid-unit? unit) (->px n unit) 0))))
+  ([v]
+   (unit->px v 0))
+  ([v initial]
+   (let [[n unit] (utils.unit/parse v)]
+     (if (empty? unit)
+       n
+       (if (valid-unit? unit)
+         (->px n unit)
+         initial))))
+  ([v tag attr]
+   (let [initial (utils.attribute/initial-memo tag attr)]
+     (unit->px v (unit->px initial 0)))))
 
 (m/=> transform [:-> [:or string? number? nil?] ifn? [:* any?] string?])
 (defn transform